ruby-lsp 0.3.8 → 0.4.1

data/lib/ruby_lsp/requests/code_actions.rb

@@ -23,25 +23,55 @@ module RubyLsp
         params(
           uri: String,
           document: Document,
-          range: T::Range[Integer],
+          range: Document::RangeShape,
+          context: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(uri, document, range)
+      def initialize(uri, document, range, context)
         super(document)
 
         @uri = uri
         @range = range
+        @context = context
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::CodeAction], Object))) }
       def run
-        diagnostics = @document.cache_fetch(:diagnostics) { Diagnostics.new(@uri, @document).run }
-        corrections = diagnostics.select do |diagnostic|
-          diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
+        diagnostics = @context[:diagnostics]
+
+        code_actions = diagnostics.filter_map do |diagnostic|
+          code_action = diagnostic.dig(:data, :code_action)
+          next if code_action.nil?
+
+          # We want to return only code actions that are within range or that do not have any edits, such as refactor
+          # code actions
+          range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
+          code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
-        return [] if corrections.empty?
 
-        T.cast(corrections, T::Array[Support::RuboCopDiagnostic]).map!(&:to_lsp_code_action)
+        code_actions << refactor_code_action(@range, @uri)
+      end
+
+      private
+
+      sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
+      def cover?(range)
+        range.nil? ||
+          ((@range.dig(:start, :line))..(@range.dig(:end, :line))).cover?(
+            (range.dig(:start, :line))..(range.dig(:end, :line)),
+          )
+      end
+
+      sig { params(range: Document::RangeShape, uri: String).returns(Interface::CodeAction) }
+      def refactor_code_action(range, uri)
+        Interface::CodeAction.new(
+          title: "Refactor: Extract Variable",
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          data: {
+            range: range,
+            uri: uri,
+          },
+        )
       end
     end
   end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -15,7 +15,7 @@ module RubyLsp
     #
     # ```ruby
     # def say_hello
-    # puts "Hello" # --> diagnostics: incorrect indentantion
+    # puts "Hello" # --> diagnostics: incorrect indentation
     # end
     # ```
     class Diagnostics < BaseRequest
@@ -28,17 +28,13 @@ module RubyLsp
         @uri = uri
       end
 
-      sig do
-        override.returns(
-          T.any(
-            T.all(T::Array[Support::RuboCopDiagnostic], Object),
-            T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
-          ),
-        )
-      end
+      sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
       def run
-        return [] if @document.syntax_error?
-        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
+        return if @document.syntax_error?
+        return unless defined?(Support::RuboCopDiagnosticsRunner)
+
+        # Don't try to run RuboCop diagnostics for files outside the current working directory
+        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/formatting.rb

@@ -32,8 +32,13 @@ module RubyLsp
         @uri = uri
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
+        # Don't try to format files outside the current working directory
+        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
+
+        return if @document.syntax_error?
+
         formatted_text = formatted_file
         return unless formatted_text
 
@@ -41,10 +46,10 @@ module RubyLsp
         return if formatted_text.size == size && formatted_text == @document.source
 
         [
-          LanguageServer::Protocol::Interface::TextEdit.new(
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(line: 0, character: 0),
-              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size),
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: 0, character: 0),
+              end: Interface::Position.new(line: size, character: size),
             ),
             new_text: formatted_text,
           ),

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -32,8 +32,8 @@ module RubyLsp
 
         scanner = document.create_scanner
         line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
-        line_end = scanner.find_char_position(position)
-        line = T.must(@document.source[line_begin..line_end])
+        @line_end = T.let(scanner.find_char_position(position), Integer)
+        line = T.must(@document.source[line_begin..@line_end])
 
         @indentation = T.let(find_indentation(line), Integer)
         @previous_line = T.let(line.strip.chomp, String)
@@ -42,7 +42,7 @@ module RubyLsp
         @trigger_character = trigger_character
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
       def run
         case @trigger_character
         when "{"
@@ -84,8 +84,30 @@ module RubyLsp
 
         indents = " " * @indentation
 
-        add_edit_with_text(" \n#{indents}end")
-        move_cursor_to(@position[:line], @indentation + 2)
+        if @previous_line.include?("\n")
+          # If the previous line has a line break, then it means there's content after the line break that triggered
+          # this completion. For these cases, we want to add the `end` after the content and move the cursor back to the
+          # keyword that triggered the completion
+
+          line = @position[:line]
+
+          # If there are enough lines in the document, we want to add the `end` token on the line below the extra
+          # content. Otherwise, we want to insert and extra line break ourselves
+          correction = if T.must(@document.source[@line_end..-1]).count("\n") >= 2
+            line -= 1
+            "#{indents}end"
+          else
+            "#{indents}\nend"
+          end
+
+          add_edit_with_text(correction, { line: @position[:line] + 1, character: @position[:character] })
+          move_cursor_to(line, @indentation + 3)
+        else
+          # If there's nothing after the new line break that triggered the completion, then we want to add the `end` and
+          # move the cursor to the body of the statement
+          add_edit_with_text(" \n#{indents}end")
+          move_cursor_to(@position[:line], @indentation + 2)
+        end
       end
 
       sig { params(spaces: String).void }
@@ -94,18 +116,15 @@ module RubyLsp
         move_cursor_to(@position[:line], @indentation + spaces.size + 1)
       end
 
-      sig { params(text: String).void }
-      def add_edit_with_text(text)
-        position = Interface::Position.new(
-          line: @position[:line],
-          character: @position[:character],
+      sig { params(text: String, position: Document::PositionShape).void }
+      def add_edit_with_text(text, position = @position)
+        pos = Interface::Position.new(
+          line: position[:line],
+          character: position[:character],
         )
 
         @edits << Interface::TextEdit.new(
-          range: Interface::Range.new(
-            start: position,
-            end: position,
-          ),
+          range: Interface::Range.new(start: pos, end: pos),
           new_text: text,
         )
       end

data/lib/ruby_lsp/requests/path_completion.rb

@@ -0,0 +1,95 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Path completion demo](../../misc/path_completion.gif)
+    #
+    # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
+    # request looks up Ruby files in the $LOAD_PATH to suggest path completion inside `require` statements.
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
+    # ```
+    class PathCompletion < BaseRequest
+      extend T::Sig
+
+      sig { params(document: Document, position: Document::PositionShape).void }
+      def initialize(document, position)
+        super(document)
+
+        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
+        @position = position
+      end
+
+      sig { override.returns(T.all(T::Array[Interface::CompletionItem], Object)) }
+      def run
+        # We can't verify if we're inside a require when there are syntax errors
+        return [] if @document.syntax_error?
+
+        char_position = @document.create_scanner.find_char_position(@position)
+        target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
+        # no target means the we are not inside a `require` call
+        return [] unless target
+
+        text = target.value
+        @tree.search(text).sort.map! do |path|
+          build_completion(path, path.delete_prefix(text))
+        end
+      end
+
+      private
+
+      sig { returns(T::Array[String]) }
+      def collect_load_path_files
+        $LOAD_PATH.flat_map do |p|
+          Dir.glob("**/*.rb", base: p)
+        end.map! do |result|
+          result.delete_suffix!(".rb")
+        end
+      end
+
+      sig { params(position: Integer).returns(T.nilable(SyntaxTree::TStringContent)) }
+      def find(position)
+        matched, parent = locate(
+          T.must(@document.tree),
+          position,
+          node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
+        )
+
+        return unless matched && parent
+
+        case matched
+        when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
+          return unless matched.message.value == "require"
+
+          args = matched.arguments
+          args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
+
+          path_node = args.parts.first.parts.first
+          return unless path_node
+          return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
+
+          path_node
+        end
+      end
+
+      sig { params(label: String, insert_text: String).returns(Interface::CompletionItem) }
+      def build_completion(label, insert_text)
+        Interface::CompletionItem.new(
+          label: label,
+          text_edit: Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: @position,
+              end: @position,
+            ),
+            new_text: insert_text,
+          ),
+          kind: Constant::CompletionItemKind::REFERENCE,
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -20,7 +20,7 @@ module RubyLsp
     # ```
     class SemanticHighlighting < BaseRequest
       extend T::Sig
-      include SyntaxTree::WithEnvironment
+      include SyntaxTree::WithScope
 
       TOKEN_TYPES = T.let(
         {
@@ -78,11 +78,28 @@ module RubyLsp
         T::Array[String],
       )
 
-      class SemanticToken < T::Struct
-        const :location, SyntaxTree::Location
-        const :length, Integer
-        const :type, Integer
-        const :modifier, T::Array[Integer]
+      class SemanticToken
+        extend T::Sig
+
+        sig { returns(SyntaxTree::Location) }
+        attr_reader :location
+
+        sig { returns(Integer) }
+        attr_reader :length
+
+        sig { returns(Integer) }
+        attr_reader :type
+
+        sig { returns(T::Array[Integer]) }
+        attr_reader :modifier
+
+        sig { params(location: SyntaxTree::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
+        def initialize(location:, length:, type:, modifier:)
+          @location = location
+          @length = length
+          @type = type
+          @modifier = modifier
+        end
       end
 
       sig do
@@ -126,8 +143,10 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        unless message == :call || special_method?(message.value)
-          add_token(message.location, :method)
+        if message != :call && !special_method?(message.value)
+          type = Support::Sorbet.annotation?(node) ? :type : :method
+
+          add_token(message.location, type)
         end
 
         visit(node.arguments)
@@ -137,7 +156,9 @@ module RubyLsp
       def visit_command(node)
         return super unless visible?(node, @range)
 
-        add_token(node.message.location, :method) unless special_method?(node.message.value)
+        unless special_method?(node.message.value)
+          add_token(node.message.location, :method)
+        end
         visit(node.arguments)
       end
 
@@ -243,7 +264,10 @@ module RubyLsp
       def visit_vcall(node)
         return super unless visible?(node, @range)
 
-        add_token(node.value.location, :method) unless special_method?(node.value.value)
+        return if special_method?(node.value.value)
+
+        type = Support::Sorbet.annotation?(node) ? :type : :method
+        add_token(node.value.location, type)
       end
 
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
@@ -305,7 +329,7 @@ module RubyLsp
 
       sig { params(value: SyntaxTree::Ident).returns(Symbol) }
       def type_for_local(value)
-        local = current_environment.find_local(value.value)
+        local = current_scope.find_local(value.value)
 
         if local.nil? || local.type == :variable
           :variable

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

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class Annotation
+        extend T::Sig
+        sig do
+          params(
+            arity: T.any(Integer, T::Range[Integer]),
+            receiver: T::Boolean,
+          ).void
+        end
+        def initialize(arity:, receiver: false)
+          @arity = arity
+          @receiver = receiver
+        end
+
+        sig { returns(T.any(Integer, T::Range[Integer])) }
+        attr_reader :arity
+
+        sig { returns(T::Boolean) }
+        attr_reader :receiver
+
+        sig { params(arity: T.any(T::Range[Integer], Integer)).returns(T::Boolean) }
+        def supports_arity?(arity)
+          if @arity.is_a?(Integer)
+            @arity == arity
+          elsif @arity.is_a?(Range)
+            @arity.cover?(arity)
+          else
+            T.absurd(@arity)
+          end
+        end
+
+        sig { params(receiver: T.nilable(String)).returns(T::Boolean) }
+        def supports_receiver?(receiver)
+          return receiver.nil? || receiver.empty? if @receiver == false
+
+          receiver == "T"
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,20 @@ module RubyLsp
         READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
         WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
 
-        class HighlightMatch < T::Struct
-          const :type, Integer
-          const :node, SyntaxTree::Node
+        class HighlightMatch
+          extend T::Sig
+
+          sig { returns(Integer) }
+          attr_reader :type
+
+          sig { returns(SyntaxTree::Node) }
+          attr_reader :node
+
+          sig { params(type: Integer, node: SyntaxTree::Node).void }
+          def initialize(type:, node:)
+            @type = type
+            @node = node
+          end
         end
 
         sig { params(node: SyntaxTree::Node).void }

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

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class PrefixTree
+        extend T::Sig
+
+        sig { params(items: T::Array[String]).void }
+        def initialize(items)
+          @root = T.let(Node.new(""), Node)
+
+          items.each do |item|
+            insert(item)
+          end
+        end
+
+        sig { params(prefix: String).returns(T::Array[String]) }
+        def search(prefix)
+          node = T.let(@root, Node)
+
+          prefix.each_char do |char|
+            snode = node.children[char]
+            return [] unless snode
+
+            node = snode
+          end
+
+          node.collect
+        end
+
+        private
+
+        sig { params(item: String).void }
+        def insert(item)
+          node = T.let(@root, Node)
+
+          item.each_char do |char|
+            node = node.children[char] ||= Node.new(node.value + char)
+          end
+
+          node.leaf = true
+        end
+
+        class Node
+          extend T::Sig
+
+          sig { returns(T::Hash[String, Node]) }
+          attr_reader :children
+
+          sig { returns(String) }
+          attr_reader :value
+
+          sig { returns(T::Boolean) }
+          attr_accessor :leaf
+
+          sig { params(value: String).void }
+          def initialize(value)
+            @children = T.let({}, T::Hash[String, Node])
+            @value = T.let(value, String)
+            @leaf = T.let(false, T::Boolean)
+          end
+
+          sig { returns(T::Array[String]) }
+          def collect
+            result = T.let([], T::Array[String])
+            result << value if leaf
+
+            children.each_value do |node|
+              result.concat(node.collect)
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,52 +9,35 @@ module RubyLsp
 
         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,
+            convention: Constant::DiagnosticSeverity::INFORMATION,
+            info: Constant::DiagnosticSeverity::INFORMATION,
+            refactor: Constant::DiagnosticSeverity::INFORMATION,
+            warning: Constant::DiagnosticSeverity::WARNING,
+            error: Constant::DiagnosticSeverity::ERROR,
+            fatal: 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) }
+        sig { returns(Interface::CodeAction) }
         def to_lsp_code_action
-          LanguageServer::Protocol::Interface::CodeAction.new(
+          Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
-            kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-            edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
               document_changes: [
-                LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                  text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
                     uri: @uri,
                     version: nil,
                   ),
-                  edits: @replacements,
+                  edits: @offense.correctable? ? offense_replacements : [],
                 ),
               ],
             ),
@@ -62,45 +45,47 @@ module RubyLsp
           )
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
+        sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
           if @offense.correctable?
             severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
             message = @offense.message
           else
-            severity = LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING
+            severity = Constant::DiagnosticSeverity::WARNING
             message = "#{@offense.message}\n\nThis offense is not auto-correctable.\n"
           end
-          LanguageServer::Protocol::Interface::Diagnostic.new(
+
+          Interface::Diagnostic.new(
             message: message,
             source: "RuboCop",
             code: @offense.cop_name,
             severity: severity,
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
                 line: @offense.line - 1,
                 character: @offense.column,
               ),
-              end: LanguageServer::Protocol::Interface::Position.new(
+              end: Interface::Position.new(
                 line: @offense.last_line - 1,
                 character: @offense.last_column,
               ),
             ),
+            data: {
+              correctable: @offense.correctable?,
+              code_action: to_lsp_code_action,
+            },
           )
         end
 
         private
 
-        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+        sig { returns(T::Array[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,
-                ),
+            Interface::TextEdit.new(
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: range.line - 1, character: range.column),
+                end: Interface::Position.new(line: range.last_line - 1, character: range.last_column),
               ),
               new_text: replacement,
             )

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

@@ -21,7 +21,7 @@ module RubyLsp
           @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { params(uri: String, document: Document).returns(String) }
         def run(uri, document)
           filename = CGI.unescape(URI.parse(uri).path)