ruby-lsp 0.0.4 → 0.2.1

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -1,8 +1,10 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Selection ranges demo](../../misc/selection_ranges.gif)
+    #
     # The [selection ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange)
     # request informs the editor of ranges that the user may want to select based on the location(s)
     # of their cursor(s).
@@ -17,7 +19,9 @@ module RubyLsp
     # end
     # ```
     class SelectionRanges < BaseRequest
-      NODES_THAT_CAN_BE_PARENTS = [
+      extend T::Sig
+
+      NODES_THAT_CAN_BE_PARENTS = T.let([
         SyntaxTree::Assign,
         SyntaxTree::ArrayLiteral,
         SyntaxTree::Begin,
@@ -54,15 +58,17 @@ module RubyLsp
         SyntaxTree::VCall,
         SyntaxTree::When,
         SyntaxTree::While,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
+      sig { params(document: Document).void }
       def initialize(document)
         super(document)
 
-        @ranges = []
-        @stack = []
+        @ranges = T.let([], T::Array[Support::SelectionRange])
+        @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
+      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
         visit(@document.tree)
         @ranges.reverse!
@@ -70,6 +76,7 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return if node.nil?
 
@@ -83,6 +90,12 @@ module RubyLsp
         @stack.pop if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
       end
 
+      sig do
+        params(
+          location: SyntaxTree::Location,
+          parent: T.nilable(Support::SelectionRange)
+        ).returns(Support::SelectionRange)
+      end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
           range: LanguageServer::Protocol::Interface::Range.new(

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -1,8 +1,10 @@
-# typed: true
+# 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.
@@ -17,12 +19,35 @@ module RubyLsp
     # end
     # ```
     class SemanticHighlighting < BaseRequest
-      TOKEN_TYPES = [
-        :variable,
-        :method,
-      ].freeze
-
-      TOKEN_MODIFIERS = {
+      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,
@@ -33,18 +58,38 @@ module RubyLsp
         modification: 7,
         documentation: 8,
         default_library: 9,
-      }.freeze
-
-      SemanticToken = Struct.new(:location, :length, :type, :modifier)
+      }.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(T.must(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
@@ -52,60 +97,158 @@ 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
+
+        rest = node.keyword_rest
+        return if rest.nil? || rest.is_a?(SyntaxTree::ArgsForward)
+
+        name = rest.name
+        add_token(name.location, :variable) if name
+      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
 
+      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, length, TOKEN_TYPES.index(type), modifiers_indices))
+        @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/highlight_target.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class HighlightTarget
+        extend T::Sig
+
+        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+
+        class HighlightMatch < T::Struct
+          const :type, Integer
+          const :node, SyntaxTree::Node
+        end
+
+        sig { params(node: SyntaxTree::Node).void }
+        def initialize(node)
+          @node = node
+          @value = T.let(value(node), T.nilable(String))
+        end
+
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def highlight_type(other)
+          matched_highlight(other) if other.is_a?(SyntaxTree::Params) || (@value && @value == value(other))
+        end
+
+        private
+
+        # Match the target type (where the cursor is positioned) with the `other` type (the node we're currently
+        # visiting)
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def matched_highlight(other)
+          case @node
+          # Method definitions and invocations
+          when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command,
+               SyntaxTree::CommandCall, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless
+            case other
+            when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::Defs
+              HighlightMatch.new(type: WRITE, node: other.name)
+            end
+          # Variables, parameters and constants
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::VarField,
+               SyntaxTree::VarRef, SyntaxTree::Ident
+            case other
+            when SyntaxTree::VarField
+              HighlightMatch.new(type: WRITE, node: other)
+            when SyntaxTree::VarRef
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+              HighlightMatch.new(type: WRITE, node: other.constant)
+            when SyntaxTree::ConstPathRef
+              HighlightMatch.new(type: READ, node: other.constant)
+            when SyntaxTree::Params
+              params = other.child_nodes.compact
+              match = params.find { |param| value(param) == @value }
+              HighlightMatch.new(type: WRITE, node: match) if match
+            end
+          end
+        end
+
+        sig { params(node: SyntaxTree::Node).returns(T.nilable(String)) }
+        def value(node)
+          case node
+          when SyntaxTree::ConstPathRef, SyntaxTree::ConstPathField, SyntaxTree::TopConstField
+            node.constant.value
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident,
+               SyntaxTree::ArgsForward
+            node.value
+          when SyntaxTree::Field, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless, SyntaxTree::RestParam,
+               SyntaxTree::KwRestParam, SyntaxTree::BlockArg
+            node.name&.value
+          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall, SyntaxTree::FCall
+            node.value&.value
+          when SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+            node.message.value
+          when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+            node.constant.constant.value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,35 +1,45 @@
-# typed: true
+# 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}",
@@ -49,6 +59,7 @@ module RubyLsp
           )
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
         def to_lsp_diagnostic
           LanguageServer::Protocol::Interface::Diagnostic.new(
             message: @offense.message,
@@ -70,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,10 +1,13 @@
-# typed: true
+# 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,15 +1,23 @@
-# typed: true
+# 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|
@@ -31,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
@@ -49,6 +58,7 @@ module RubyLsp
         # 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)

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

@@ -1,18 +1,23 @@
-# typed: true
+# 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",