ruby-lsp 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5d9c6b487aab55ce25eb2741fff92afa8ca0ee544f21374debacce7f887cc50
-  data.tar.gz: 8da9da85900753306f5e8558bc1a42f25b7173ffe1087ea70612c10ef5558e27
+  metadata.gz: f7bf79fd6cdc704c8f874f58985f0e72ac034c76bb70a68166654185f6f00cf1
+  data.tar.gz: '083edc726c05ffb6e5e3ae63d480b17fa0f7161ee62349665cc57e309acd5598'
 SHA512:
-  metadata.gz: 3dca630b9cae262f1af8d0aef0300ab7399dafd348db5f578ed7fdffb22a7afd48fe9467aa65e467fb50e16663f8fad32f1d0cc46b30819b06a6b7472700dcc0
-  data.tar.gz: f048c6c9fe14d20edefeca7ac504942af34c61699163f0d09ec54f4d80e7469e1bb1762757b96aa3d8d06a6e8168473dacfc932112b2d31ca4b380748eef8899
+  metadata.gz: f6192daf27dfd82dbb505f5184eebd66308690ce10ead4d4cedc4d9c6667be882a8b9de4c87e66eb88ff43e896307be24bbcc6506b0544b496e1bcb3c9804498
+  data.tar.gz: bb68928d9a72b3b2873509bf915f753a202a520187bf5f55da1870d552e0ba0917a7d21ea70d20853ac60aa614f7d85d117d7291ec9c0778cab80e4561a7aba0

data/README.md

@@ -1,57 +1,50 @@
-![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)
+[![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
+[![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew)
 
-# Ruby LSP
-
-This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
-
-# Overview
-
-The intention of Ruby LSP is to provide a fast, robust and feature-rich coding environment for Ruby developers.
-
-It's part of a [wider Shopify goal](https://github.com/Shopify/vscode-shopify-ruby) to provide a state-of-the-art experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-It provides many features, including:
-
-* Syntax highlighting
-* Linting and formatting
-* Code folding
-* Selection ranges
-
-It does not perform typechecking, so its features are implemented on a best-effort basis, aiming to be as accurate as possible.
-
-Planned future features include:
+# Ruby LSP
 
-* Auto-completion and navigation ("Go To Definition") ([prototype](https://github.com/Shopify/ruby-lsp/pull/429))
-* Support for plug-ins to extend behavior
+The Ruby LSP is an implementation of the [language server protocol](https://microsoft.github.io/language-server-protocol/)
+for Ruby, used to improve rich features in editors. It is a part of a wider goal to provide a state-of-the-art
+experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-The Ruby LSP does not perform any type-checking or provide any type-related assistance, but it can be used alongside [Sorbet](https://github.com/sorbet/sorbet)'s LSP server.
+Want to discuss Ruby developer experience? Consider joining the public
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew).
 
-At the time of writing, these are the major differences between Ruby LSP and [Solargraph](https://solargraph.org/):
+## Usage
 
-* Solargraph [uses](https://solargraph.org/guides/yard) YARD documentation to gather information about your project and its gem dependencies. This provides functionality such as context-aware auto-completion and navigation ("Go To Definition")
-* Solargraph can be used as a globally installed gem, but Ruby LSP must be added to the Gemfile or gemspec if using RuboCop. (There are pros and cons to each approach)
+### With VS Code
 
-## Learn More
+If using VS Code, all you have to do is install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to
+get the extra features in the editor. Do not install this gem manually.
 
-* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+### With other editors
 
-## Usage
+See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on setting up the
+Ruby LSP.
 
-Install the gem. There's no need to require it, since the server is used as a standalone executable.
+The gem can be installed by doing
+```shell
+gem install ruby-lsp
+```
 
+If you decide to add the gem to the bundle, it is not necessary to require it.
 ```ruby
 group :development do
   gem "ruby-lsp", require: false
 end
 ```
 
-If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features
-in the editor. See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on
-setting up the Ruby LSP in different editors.
+### Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
+## Learn More
+
+* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp.
@@ -113,7 +106,7 @@ To add a new expectations test runner for a new request handler:
     * Tests with expectations will be checked with `assert_expectations`
     * Tests without expectations will be ran against your new $HANDLER to check that nothing breaks
 
-## Debugging
+### Debugging
 
 ### Debugging Tests
 
@@ -135,7 +128,7 @@ To add a new expectations test runner for a new request handler:
 7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.
 8. In your `Extension Development Host` project (e.g. [`Tapioca`](https://github.com/Shopify/tapioca)), trigger the request that will hit the breakpoint.
 
-## Spell Checking
+### Spell Checking
 
 VS Code users will be prompted to enable the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension.
 By default this will be enabled for all workspaces, but you can choose to selectively enable or disable it per workspace.

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.3

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop"
+require "sorbet-runtime"
+
+module RuboCop
+  module Cop
+    module RubyLsp
+      # Prefer using `Interface`, `Transport` and `Constant` aliases
+      # within the `RubyLsp` module, without having to prefix with
+      # `LanguageServer::Protocol`
+      #
+      # @example
+      #   # bad
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #
+      #   # good
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #   end
+      class UseLanguageServerAliases < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+
+        MSG = "Use constant alias `%{constant}`."
+
+        def_node_search :ruby_lsp_modules, <<~PATTERN
+          (module (const nil? :RubyLsp) ...)
+        PATTERN
+
+        def_node_search :lsp_constant_usages, <<~PATTERN
+          (const (const (const nil? :LanguageServer) :Protocol) {:Interface | :Transport | :Constant})
+        PATTERN
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          ruby_lsp_modules(processed_source.ast).each do |ruby_lsp_mod|
+            lsp_constant_usages(ruby_lsp_mod).each do |node|
+              lsp_const = node.children.last
+
+              next unless ALIASED_CONSTANTS.include?(lsp_const)
+
+              add_offense(node, message: format(MSG, constant: lsp_const)) do |corrector|
+                corrector.replace(node, lsp_const)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -15,11 +15,19 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :source
 
-    sig { params(source: String, encoding: String).void }
-    def initialize(source, encoding = "utf-8")
+    sig { returns(Integer) }
+    attr_reader :version
+
+    sig { returns(String) }
+    attr_reader :uri
+
+    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    def initialize(source:, version:, uri:, encoding: "utf-8")
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
+      @version = T.let(version, Integer)
+      @uri = T.let(uri, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
@@ -48,8 +56,8 @@ module RubyLsp
       result
     end
 
-    sig { params(edits: T::Array[EditShape]).void }
-    def push_edits(edits)
+    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
         scanner = create_scanner
@@ -60,6 +68,7 @@ module RubyLsp
         @source[start_position...end_position] = edit[:text]
       end
 
+      @version = version
       @unparsed_edits.concat(edits)
       @cache.clear
     end

data/lib/ruby_lsp/executor.rb

@@ -41,7 +41,11 @@ module RubyLsp
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
-        text_document_did_open(uri, request.dig(:params, :textDocument, :text))
+        text_document_did_open(
+          uri,
+          request.dig(:params, :textDocument, :text),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/didClose"
         @notifications << Notification.new(
           message: "textDocument/publishDiagnostics",
@@ -50,7 +54,11 @@ module RubyLsp
 
         text_document_did_close(uri)
       when "textDocument/didChange"
-        text_document_did_change(uri, request.dig(:params, :contentChanges))
+        text_document_did_change(
+          uri,
+          request.dig(:params, :contentChanges),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/foldingRange"
         folding_range(uri)
       when "textDocument/documentLink"
@@ -138,7 +146,7 @@ module RubyLsp
     sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
     def document_link(uri)
       @store.cache_fetch(uri, :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(uri, document).run
+        RubyLsp::Requests::DocumentLink.new(document).run
       end
     end
 
@@ -149,15 +157,15 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String, content_changes: T::Array[Document::EditShape]).returns(Object) }
-    def text_document_did_change(uri, content_changes)
-      @store.push_edits(uri, content_changes)
+    sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    def text_document_did_change(uri, content_changes, version)
+      @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
     end
 
-    sig { params(uri: String, text: String).returns(Object) }
-    def text_document_did_open(uri, text)
-      @store.set(uri, text)
+    sig { params(uri: String, text: String, version: Integer).returns(Object) }
+    def text_document_did_open(uri, text, version)
+      @store.set(uri: uri, source: text, version: version)
       VOID
     end
 
@@ -207,7 +215,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
-      Requests::Formatting.new(uri, @store.get(uri), formatter: @store.formatter).run
+      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
     end
 
     sig do
@@ -250,7 +258,7 @@ module RubyLsp
     def code_action(uri, range, context)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(uri, document, range, context).run
+      Requests::CodeActions.new(document, range, context).run
     end
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
@@ -286,7 +294,7 @@ module RubyLsp
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
       response = @store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
+        Requests::Diagnostics.new(document).run
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response

data/lib/ruby_lsp/requests/base_request.rb

@@ -36,16 +36,16 @@ module RubyLsp
         nodes.each { |node| visit(node) }
       end
 
-      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
+      sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
       def range_from_syntax_tree_node(node)
         loc = node.location
 
-        LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(
+        Interface::Range.new(
+          start: 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: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
         )
       end
 

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,16 +21,15 @@ module RubyLsp
 
       sig do
         params(
-          uri: String,
           document: Document,
           range: Document::RangeShape,
           context: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(uri, document, range, context)
+      def initialize(document, range, context)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
         @range = range
         @context = context
       end
@@ -49,7 +48,9 @@ module RubyLsp
           code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
 
-        code_actions << refactor_code_action(@range, @uri)
+        # Only add refactor actions if there's a non empty selection in the editor
+        code_actions << refactor_code_action(@range, @uri) unless @range.dig(:start) == @range.dig(:end)
+        code_actions
       end
 
       private

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -21,11 +21,11 @@ module RubyLsp
     class Diagnostics < BaseRequest
       extend T::Sig
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -29,14 +29,14 @@ module RubyLsp
       def initialize(document, position)
         super(document)
 
-        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+        @highlights = T.let([], T::Array[Interface::DocumentHighlight])
         return unless document.parsed?
 
         position = document.create_scanner.find_char_position(position)
         @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
         visit(@document.tree) if @document.parsed? && @target
@@ -90,7 +90,7 @@ module RubyLsp
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @highlights << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -69,18 +69,18 @@ module RubyLsp
         end
       end
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(document: Document).void }
+      def initialize(document)
         super(document)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
-        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(document.uri)
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
+        @links = T.let([], T::Array[Interface::DocumentLink])
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentLink], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @links
@@ -91,12 +91,12 @@ module RubyLsp
         match = node.value.match(%r{source://.*#\d+$})
         return unless match
 
-        uri = T.cast(URI(match[0]), URI::Source)
+        uri = T.cast(URI(T.must(match[0])), URI::Source)
         gem_version = T.must(resolve_version(uri))
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
         return if file_path.nil?
 
-        @links << LanguageServer::Protocol::Interface::DocumentLink.new(
+        @links << Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
           target: "file://#{file_path}##{uri.line_number}",
           tooltip: "Jump to #{file_path}##{uri.line_number}",

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -66,12 +66,12 @@ module RubyLsp
       class SymbolHierarchyRoot
         extend T::Sig
 
-        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
+        sig { returns(T::Array[Interface::DocumentSymbol]) }
         attr_reader :children
 
         sig { void }
         def initialize
-          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
+          @children = T.let([], T::Array[Interface::DocumentSymbol])
         end
       end
 
@@ -82,11 +82,11 @@ module RubyLsp
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @stack = T.let(
           [@root],
-          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)],
+          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
         )
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @root.children
@@ -134,7 +134,9 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        if node.target&.value&.value == "self"
+        target = node.target
+
+        if target.is_a?(SyntaxTree::VarRef) && target.value.is_a?(SyntaxTree::Kw) && target.value.value == "self"
           name = "self.#{node.name.value}"
           kind = :method
         else
@@ -180,7 +182,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
-        kind = case node.value
+        value = node.value
+        kind = case value
         when SyntaxTree::Const
           :constant
         when SyntaxTree::CVar, SyntaxTree::IVar
@@ -190,10 +193,10 @@ module RubyLsp
         end
 
         create_document_symbol(
-          name: node.value.value,
+          name: value.value,
           kind: kind,
           range_node: node,
-          selection_range_node: node.value,
+          selection_range_node: value,
         )
       end
 
@@ -205,10 +208,10 @@ module RubyLsp
           kind: Symbol,
           range_node: SyntaxTree::Node,
           selection_range_node: SyntaxTree::Node,
-        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+        ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
-        symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
+        symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: SYMBOL_KIND[kind],
           range: range_from_syntax_tree_node(range_node),

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -63,11 +63,11 @@ module RubyLsp
       def initialize(document)
         super
 
-        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @ranges = T.let([], T::Array[Interface::FoldingRange])
         @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
       def run
         if @document.parsed?
           visit(@document.tree)
@@ -161,9 +161,9 @@ module RubyLsp
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
+        sig { returns(Interface::FoldingRange) }
         def to_range
-          LanguageServer::Protocol::Interface::FoldingRange.new(
+          Interface::FoldingRange.new(
             start_line: @start_line,
             end_line: @end_line,
             kind: @kind,
@@ -220,7 +220,8 @@ module RubyLsp
 
       sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
-        receiver = T.let(node.receiver, SyntaxTree::Node)
+        receiver = T.let(node.receiver, T.nilable(SyntaxTree::Node))
+
         loop do
           case receiver
           when SyntaxTree::CallNode
@@ -255,9 +256,10 @@ module RubyLsp
       def add_def_range(node)
         # For an endless method with no arguments, `node.params` returns `nil` for Ruby 3.0, but a `Syntax::Params`
         # for Ruby 3.1
-        return unless node.params
+        params = node.params
+        return unless params
 
-        params_location = node.params.location
+        params_location = params.location
 
         if params_location.start_line < params_location.end_line
           add_lines_range(params_location.end_line, node.location.end_line - 1)
@@ -276,7 +278,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
-        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
+        return if statements.empty?
+
+        add_lines_range(node.location.start_line, T.must(statements.body.last).location.end_line)
       end
 
       sig { params(node: SyntaxTree::StringConcat).void }
@@ -291,7 +295,7 @@ module RubyLsp
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 
-        @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
+        @ranges << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/requests/formatting.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_formatting_runner"
+require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
 
 module RubyLsp
   module Requests
@@ -26,11 +27,11 @@ module RubyLsp
 
       extend T::Sig
 
-      sig { params(uri: String, document: Document, formatter: String).void }
-      def initialize(uri, document, formatter: "auto")
+      sig { params(document: Document, formatter: String).void }
+      def initialize(document, formatter: "auto")
         super(document)
 
-        @uri = uri
+        @uri = T.let(document.uri, String)
         @formatter = T.let(
           if formatter == "auto"
             defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
@@ -73,7 +74,7 @@ module RubyLsp
         when "rubocop"
           Support::RuboCopFormattingRunner.instance.run(@uri, @document)
         when "syntax_tree"
-          SyntaxTree.format(@document.source)
+          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
         else
           raise InvalidFormatter, "Unknown formatter: #{@formatter}"
         end

data/lib/ruby_lsp/requests/hover.rb

@@ -36,7 +36,7 @@ module RubyLsp
         @position = T.let(document.create_scanner.find_char_position(position), Integer)
       end
 
-      sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
+      sig { override.returns(T.nilable(Interface::Hover)) }
       def run
         return unless @document.parsed?
 
@@ -48,9 +48,10 @@ module RubyLsp
           message = target.message
           generate_rails_document_link_hover(message.value, message)
         when SyntaxTree::CallNode
-          return if target.message == :call
+          message = target.message
+          return if message.is_a?(Symbol)
 
-          generate_rails_document_link_hover(target.message.value, target.message)
+          generate_rails_document_link_hover(message.value, message)
         when SyntaxTree::ConstPathRef
           constant_name = full_constant_name(target)
           generate_rails_document_link_hover(constant_name, target)
@@ -60,18 +61,18 @@ module RubyLsp
       private
 
       sig do
-        params(name: String, node: SyntaxTree::Node).returns(T.nilable(LanguageServer::Protocol::Interface::Hover))
+        params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover))
       end
       def generate_rails_document_link_hover(name, node)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
 
         return if urls.empty?
 
-        contents = LanguageServer::Protocol::Interface::MarkupContent.new(
+        contents = Interface::MarkupContent.new(
           kind: "markdown",
           value: urls.join("\n\n"),
         )
-        LanguageServer::Protocol::Interface::Hover.new(
+        Interface::Hover.new(
           range: range_from_syntax_tree_node(node),
           contents: contents,
         )

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -25,11 +25,11 @@ module RubyLsp
       def initialize(document, range)
         super(document)
 
-        @hints = T.let([], T::Array[LanguageServer::Protocol::Interface::InlayHint])
+        @hints = T.let([], T::Array[Interface::InlayHint])
         @range = range
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::InlayHint], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @hints
@@ -37,12 +37,13 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Rescue).void }
       def visit_rescue(node)
-        return unless node.exception.nil?
+        exception = node.exception
+        return unless exception.nil? || exception.exceptions.nil?
 
         loc = node.location
         return unless visible?(node, @range)
 
-        @hints << LanguageServer::Protocol::Interface::InlayHint.new(
+        @hints << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,

data/lib/ruby_lsp/requests/path_completion.rb

@@ -63,13 +63,19 @@ module RubyLsp
 
         case matched
         when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
-          return unless matched.message.value == "require"
+          message = matched.message
+          return if message.is_a?(Symbol)
+          return unless message.value == "require"
 
           args = matched.arguments
           args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
+          return if args.nil? || args.is_a?(SyntaxTree::ArgsForward)
 
-          path_node = args.parts.first.parts.first
-          return unless path_node
+          argument = args.parts.first
+          return unless argument.is_a?(SyntaxTree::StringLiteral)
+
+          path_node = argument.parts.first
+          return unless path_node.is_a?(SyntaxTree::TStringContent)
           return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
 
           path_node

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -100,12 +100,12 @@ module RubyLsp
       end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(
               line: location.start_line - 1,
               character: location.start_column,
             ),
-            end: LanguageServer::Protocol::Interface::Position.new(
+            end: Interface::Position.new(
               line: location.end_line - 1,
               character: location.end_column,
             ),

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -122,7 +122,7 @@ module RubyLsp
       sig do
         override.returns(
           T.any(
-            LanguageServer::Protocol::Interface::SemanticTokens,
+            Interface::SemanticTokens,
             T.all(T::Array[SemanticToken], Object),
           ),
         )
@@ -143,7 +143,7 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        if message != :call && !special_method?(message.value)
+        if !message.is_a?(Symbol) && !special_method?(message.value)
           type = Support::Sorbet.annotation?(node) ? :type : :method
 
           add_token(message.location, type)
@@ -168,7 +168,8 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         visit(node.receiver)
-        add_token(node.message.location, :method)
+        message = node.message
+        add_token(message.location, :method) unless message.is_a?(Symbol)
         visit(node.arguments)
         visit(node.block)
       end
@@ -205,7 +206,7 @@ module RubyLsp
       def visit_params(node)
         return super unless visible?(node, @range)
 
-        node.keywords.each do |keyword,|
+        node.keywords.each do |keyword, *|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
         end
@@ -215,7 +216,7 @@ module RubyLsp
         end
 
         rest = node.keyword_rest
-        if rest && !rest.is_a?(SyntaxTree::ArgsForward)
+        if rest && !rest.is_a?(SyntaxTree::ArgsForward) && !rest.is_a?(Symbol)
           name = rest.name
           add_token(name.location, :parameter) if name
         end
@@ -238,9 +239,14 @@ module RubyLsp
 
         value = node.value
 
-        if value.is_a?(SyntaxTree::Ident)
+        case value
+        when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
+        else
+          visit(value)
         end
 
         super
@@ -256,6 +262,8 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
         else
           visit(value)
         end
@@ -305,18 +313,21 @@ module RubyLsp
         return unless node.operator == :=~
 
         left = node.left
+        # The regexp needs to be on the left hand side of the =~ for local variable capture
+        return unless left.is_a?(SyntaxTree::RegexpLiteral)
+
         parts = left.parts
+        return unless parts.one?
 
-        if left.is_a?(SyntaxTree::RegexpLiteral) && parts.one? && parts.first.is_a?(SyntaxTree::TStringContent)
-          content = parts.first
+        content = parts.first
+        return unless content.is_a?(SyntaxTree::TStringContent)
 
-          # For each capture name we find in the regexp, look for a local in the current_scope
-          Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
-            local = current_scope.find_local(name)
-            next unless local
+        # For each capture name we find in the regexp, look for a local in the current_scope
+        Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
+          local = current_scope.find_local(name)
+          next unless local
 
-            local.definitions.each { |definition| add_token(definition, :variable) }
-          end
+          local.definitions.each { |definition| add_token(definition, :variable) }
         end
       end
 
@@ -325,7 +336,10 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         add_token(node.constant.location, :class, [:declaration])
-        add_token(node.superclass.location, :class) if node.superclass
+
+        superclass = node.superclass
+        add_token(superclass.location, :class) if superclass
+
         visit(node.bodystmt)
       end
 

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

@@ -7,8 +7,8 @@ module RubyLsp
       class HighlightTarget
         extend T::Sig
 
-        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+        READ = Constant::DocumentHighlightKind::READ
+        WRITE = Constant::DocumentHighlightKind::WRITE
 
         class HighlightMatch
           extend T::Sig
@@ -84,10 +84,11 @@ module RubyLsp
                SyntaxTree::KwRestParam, SyntaxTree::BlockArg
             node.name&.value
           when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
-            node.value&.value
+            value = node.value
+            value.value unless value.nil? || value.is_a?(Symbol)
           when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
             message = node.message
-            message != :call ? message.value : nil
+            message.value unless message.is_a?(Symbol)
           when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
             node.constant.constant.value
           end

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

@@ -67,12 +67,13 @@ module RubyLsp
             return unless RAILTIES_VERSION
 
             warn("Fetching Rails Documents...")
-            # If the version's doc is not found, e.g. Rails main, it'll be redirected
-            # In this case, we just fetch the latest doc
-            response = if Gem::Version.new(RAILTIES_VERSION).prerelease?
-              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
-            else
-              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+
+            response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+
+            if response.code == "302"
+              # If the version's doc is not found, e.g. Rails main, it'll be redirected
+              # In this case, we just fetch the latest doc
+              response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
             end
 
             if response.code == "200"

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

@@ -4,7 +4,7 @@
 module RubyLsp
   module Requests
     module Support
-      class SelectionRange < LanguageServer::Protocol::Interface::SelectionRange
+      class SelectionRange < Interface::SelectionRange
         extend T::Sig
 
         sig { params(position: Document::PositionShape).returns(T::Boolean) }

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

@@ -16,7 +16,7 @@ module RubyLsp
         sig do
           params(
             tokens: T::Array[SemanticHighlighting::SemanticToken],
-          ).returns(LanguageServer::Protocol::Interface::SemanticTokens)
+          ).returns(Interface::SemanticTokens)
         end
         def encode(tokens)
           delta = tokens
@@ -27,7 +27,7 @@ module RubyLsp
               compute_delta(token)
             end
 
-          LanguageServer::Protocol::Interface::SemanticTokens.new(data: delta)
+          Interface::SemanticTokens.new(data: delta)
         end
 
         # The delta array is computed according to the LSP specification:

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

@@ -63,7 +63,8 @@ module RubyLsp
             when SyntaxTree::VCall
               ANNOTATIONS[node.value.value]
             when SyntaxTree::CallNode
-              ANNOTATIONS[node.message.value]
+              message = node.message
+              ANNOTATIONS[message.value] unless message.is_a?(Symbol)
             else
               T.absurd(node)
             end
@@ -84,21 +85,10 @@ module RubyLsp
           end
 
           sig do
-            params(node: T.nilable(T.any(
-              SyntaxTree::VarRef,
-              SyntaxTree::CallNode,
-              SyntaxTree::VCall,
-              SyntaxTree::Ident,
-              SyntaxTree::Backtick,
-              SyntaxTree::Const,
-              SyntaxTree::Op,
-              Symbol,
-            ))).returns(T.nilable(String))
+            params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String))
           end
           def node_name(node)
             case node
-            when NilClass
-              nil
             when SyntaxTree::VarRef
               node.value.value
             when SyntaxTree::CallNode
@@ -107,8 +97,8 @@ module RubyLsp
               node_name(node.value)
             when SyntaxTree::Ident, SyntaxTree::Backtick, SyntaxTree::Const, SyntaxTree::Op
               node.value
-            when Symbol
-              node.to_s
+            when NilClass, SyntaxTree::Node
+              nil
             else
               T.absurd(node)
             end

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

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "syntax_tree/cli"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class SyntaxTreeFormattingRunner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options =
+            T.let(
+              begin
+                opts = SyntaxTree::CLI::Options.new
+                opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
+                opts
+              end,
+              SyntaxTree::CLI::Options,
+            )
+        end
+
+        sig { params(_uri: String, document: Document).returns(T.nilable(String)) }
+        def run(_uri, document)
+          SyntaxTree.format(
+            document.source,
+            @options.print_width,
+            options: @options.formatter_options,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -2,9 +2,11 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # rubocop:disable RubyLsp/UseLanguageServerAliases
   Interface = LanguageServer::Protocol::Interface
   Constant = LanguageServer::Protocol::Constant
   Transport = LanguageServer::Protocol::Transport
+  # rubocop:enable RubyLsp/UseLanguageServerAliases
 
   class Server
     extend T::Sig
@@ -33,7 +35,8 @@ module RubyLsp
       # fall under the else branch which just pushes requests to the queue
       @reader.read do |request|
         case request[:method]
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+              "textDocument/formatting", "textDocument/onTypeFormatting", "codeAction/resolve"
           result = Executor.new(@store).execute(request)
           finalize_request(result, request)
         when "$/cancelRequest"

data/lib/ruby_lsp/store.rb

@@ -27,19 +27,19 @@ module RubyLsp
       document = @state[uri]
       return document unless document.nil?
 
-      set(uri, File.binread(CGI.unescape(URI.parse(uri).path)))
+      set(uri: uri, source: File.binread(CGI.unescape(URI.parse(uri).path)), version: 0)
       T.must(@state[uri])
     end
 
-    sig { params(uri: String, content: String).void }
-    def set(uri, content)
-      document = Document.new(content, @encoding)
+    sig { params(uri: String, source: String, version: Integer).void }
+    def set(uri:, source:, version:)
+      document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
       @state[uri] = document
     end
 
-    sig { params(uri: String, edits: T::Array[Document::EditShape]).void }
-    def push_edits(uri, edits)
-      T.must(@state[uri]).push_edits(edits)
+    sig { params(uri: String, edits: T::Array[Document::EditShape], version: Integer).void }
+    def push_edits(uri:, edits:, version:)
+      T.must(@state[uri]).push_edits(edits, version: version)
     end
 
     sig { void }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-20 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -44,7 +44,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: 6.1.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
@@ -54,7 +54,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: 6.1.1
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
@@ -70,6 +70,7 @@ files:
 - README.md
 - VERSION
 - exe/ruby-lsp
+- lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/executor.rb
@@ -102,6 +103,7 @@ files:
 - lib/ruby_lsp/requests/support/semantic_token_encoder.rb
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
+- lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/utils.rb
@@ -125,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.9
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby