ruby-lsp 0.0.3 → 0.2.0

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -1,7 +1,10 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Semantic highlighting demo](../../misc/semantic_highlighting.gif)
+    #
     # 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.
@@ -16,22 +19,77 @@ module RubyLsp
     # end
     # ```
     class SemanticHighlighting < BaseRequest
-      TOKEN_TYPES = [
-        :variable,
-        :method,
-      ].freeze
-      TOKEN_MODIFIERS = [].freeze
-
-      SemanticToken = Struct.new(:location, :length, :type, :modifier)
+      extend T::Sig
+
+      TOKEN_TYPES = T.let({
+        namespace: 0,
+        type: 1,
+        class: 2,
+        enum: 3,
+        interface: 4,
+        struct: 5,
+        typeParameter: 6,
+        parameter: 7,
+        variable: 8,
+        property: 9,
+        enumMember: 10,
+        event: 11,
+        function: 12,
+        method: 13,
+        macro: 14,
+        keyword: 15,
+        modifier: 16,
+        comment: 17,
+        string: 18,
+        number: 19,
+        regexp: 20,
+        operator: 21,
+        decorator: 22,
+      }.freeze, T::Hash[Symbol, Integer])
+
+      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])
+
+      SPECIAL_RUBY_METHODS = T.let((Module.instance_methods(false) +
+        Kernel.methods(false) + Bundler::Dsl.instance_methods(false) +
+        Module.private_instance_methods(false))
+        .map(&:to_s), T::Array[String])
+
+      class SemanticToken < T::Struct
+        const :location, SyntaxTree::Location
+        const :length, Integer
+        const :type, Integer
+        const :modifier, T::Array[Integer]
+      end
 
+      sig { params(document: Document, encoder: T.nilable(Support::SemanticTokenEncoder)).void }
       def initialize(document, encoder: nil)
         super(document)
 
         @encoder = encoder
-        @tokens = []
-        @tree = document.tree
+        @tokens = T.let([], T::Array[SemanticToken])
+        @tree = T.let(document.tree, SyntaxTree::Node)
+        @special_methods = T.let(nil, T.nilable(T::Array[String]))
       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
@@ -39,59 +97,154 @@ module RubyLsp
         @encoder.encode(@tokens)
       end
 
-      def visit_m_assign(node)
-        node.target.parts.each do |var_ref|
-          add_token(var_ref.value.location, :variable)
-        end
-      end
-
-      def visit_var_field(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
-      end
-
-      def visit_var_ref(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
-      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)
+        add_token(node.message.location, :method) unless special_method?(node.message.value)
         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
 
+      sig { params(node: SyntaxTree::Const).void }
+      def visit_const(node)
+        add_token(node.location, :namespace)
+      end
+
+      sig { params(node: SyntaxTree::Def).void }
+      def visit_def(node)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.params)
+        visit(node.bodystmt)
+      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
+
+      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
+
+      sig { params(node: SyntaxTree::FCall).void }
       def visit_fcall(node)
-        add_token(node.value.location, :method)
+        add_token(node.value.location, :method) unless special_method?(node.value.value)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::Kw).void }
+      def visit_kw(node)
+        case node.value
+        when "self"
+          add_token(node.location, :variable, [:default_library])
+        end
+      end
+
+      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
+
+      sig { params(node: SyntaxTree::Params).void }
+      def visit_params(node)
+        node.keywords.each do |keyword,|
+          location = keyword.location
+          add_token(location_without_colon(location), :variable)
+        end
+
+        add_token(node.keyword_rest.name.location, :variable) if node.keyword_rest
+      end
+
+      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
+
+      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
+
+      sig { params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
-        add_token(node.value.location, :method)
+        add_token(node.value.location, :method) unless special_method?(node.value.value)
       end
 
-      def add_token(location, type)
+      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
-        @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: location,
+            length: length,
+            type: T.must(TOKEN_TYPES[type]),
+            modifier: modifiers_indices
+          )
+        )
+      end
+
+      private
+
+      # Exclude the ":" symbol at the end of a location
+      # We use it on keyword parameters to be consistent
+      # with the rest of the parameters
+      sig { params(location: T.untyped).returns(SyntaxTree::Location) }
+      def location_without_colon(location)
+        SyntaxTree::Location.new(
+          start_line: location.start_line,
+          start_column: location.start_column,
+          start_char: location.start_char,
+          end_char: location.end_char - 1,
+          end_column: location.end_column - 1,
+          end_line: location.end_line,
+        )
+      end
+
+      # Textmate provides highlighting for a subset
+      # of these special Ruby-specific methods.
+      # We want to utilize that highlighting, so we
+      # avoid making a semantic token for it.
+      sig { params(method_name: String).returns(T::Boolean) }
+      def special_method?(method_name)
+        SPECIAL_RUBY_METHODS.include?(method_name)
       end
     end
   end

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

@@ -1,34 +1,45 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     module Support
       class RuboCopDiagnostic
-        RUBOCOP_TO_LSP_SEVERITY = {
+        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
+        }.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 = offense.correctable? ? offense_replacements : []
+          @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}",
@@ -48,6 +59,7 @@ module RubyLsp
           )
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
         def to_lsp_diagnostic
           LanguageServer::Protocol::Interface::Diagnostic.new(
             message: @offense.message,
@@ -69,6 +81,7 @@ module RubyLsp
 
         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(

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

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+require "cgi"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class RuboCopDiagnosticsRunner < RuboCop::Runner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options = T.let({}, T::Hash[Symbol, T.untyped])
+          @uri = T.let(nil, T.nilable(String))
+          @diagnostics = T.let([], T::Array[Support::RuboCopDiagnostic])
+
+          super(
+            ::RuboCop::Options.new.parse([
+              "--stderr", # Print any output to stderr so that our stdout does not get polluted
+              "--force-exclusion",
+              "--format",
+              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+            ]).first,
+            ::RuboCop::ConfigStore.new
+          )
+        end
+
+        sig { params(uri: String, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
+        def run(uri, document)
+          @diagnostics.clear
+          @uri = uri
+
+          file = CGI.unescape(URI.parse(uri).path)
+          # We communicate with Rubocop via stdin
+          @options[:stdin] = document.source
+
+          # Invoke RuboCop with just this file in `paths`
+          super([file])
+          @diagnostics
+        end
+
+        private
+
+        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        def file_finished(_file, offenses)
+          @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, T.must(@uri)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+require "cgi"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class RuboCopFormattingRunner < RuboCop::Runner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options = T.let({}, T::Hash[Symbol, T.untyped])
+
+          super(
+            ::RuboCop::Options.new.parse([
+              "--stderr", # Print any output to stderr so that our stdout does not get polluted
+              "--force-exclusion",
+              "--format",
+              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+              "-a", # --auto-correct
+            ]).first,
+            ::RuboCop::ConfigStore.new
+          )
+        end
+
+        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        def run(uri, document)
+          file = CGI.unescape(URI.parse(uri).path)
+          # We communicate with Rubocop via stdin
+          @options[:stdin] = document.source
+
+          # Invoke RuboCop with just this file in `paths`
+          super([file])
+          @options[:stdin]
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
+# 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)

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

@@ -1,14 +1,23 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     module Support
       class SemanticTokenEncoder
+        extend T::Sig
+
+        sig { void }
         def initialize
-          @current_row = 0
-          @current_column = 0
+          @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|
@@ -30,6 +39,7 @@ module RubyLsp
 
         # 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
@@ -38,11 +48,22 @@ 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.
+        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

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

@@ -1,17 +1,23 @@
+# 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",

data/lib/ruby_lsp/requests.rb

@@ -1,17 +1,29 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
+  # Supported features
+  #
+  # - {RubyLsp::Requests::DocumentSymbol}
+  # - {RubyLsp::Requests::FoldingRanges}
+  # - {RubyLsp::Requests::SelectionRanges}
+  # - {RubyLsp::Requests::SemanticHighlighting}
+  # - {RubyLsp::Requests::Formatting}
+  # - {RubyLsp::Requests::Diagnostics}
+  # - {RubyLsp::Requests::CodeActions}
+  # - {RubyLsp::Requests::DocumentHighlight}
   module Requests
     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"
 
+    # :nodoc:
     module Support
       autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
       autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"

data/lib/ruby_lsp/store.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "cgi"
@@ -6,36 +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)
-      @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
+      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