ruby-lsp 0.0.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0e94532c080cf6e443c95d9ca7ccb16f548ec45768dc58e95fd691c907a965
-  data.tar.gz: 856df7b413ef111e100ee42da541856843d966184f9dbe1dfe2ee5a50da1e802
+  metadata.gz: d067270389ee6b02bb03fb6363e272b6808e7c3d27d77354442801d09a617149
+  data.tar.gz: 74e7cd206a790a8c139969f5167ab3d38686f78646c619488153fd8ab139892e
 SHA512:
-  metadata.gz: fde4cd9c5e556ff926b22d316d1bfcc5d31c089850d4558ac7d954fe33df4c8d2b8f8c14e55d1dcc2898087d0d29e8b12fc2f768e2b14935fa727f9620ff5c9e
-  data.tar.gz: 24fb12213f36edcee13fe65d53a94977737b251566d2503dc857dc276192d6f570f93147f57fc5e3b23c8d90b2c1f96f4cc7e308d5b969a02705d39444676f95
+  metadata.gz: 8d65637f892541a79fde71e3f523dfc37c887ec4892315ffe58b450718c8fa6e2a342036c394c28f5a94da0a1348948a104609881109c5621488b9d23a581bc1
+  data.tar.gz: 1d25dbac214c23c2af2bd991d4c57bdae9dce488ac886cc700d7ab10a7e3b4a0e72ddc2c1d4be459b332e9cdfac69588d42eac11ff78023d365e0d5ef6701f78

data/.rubocop.yml

@@ -25,6 +25,16 @@ Sorbet/FalseSigil:
 Sorbet/TrueSigil:
   Enabled: true
   Include:
-    - "**/*.rb"
+    - "test/**/*.rb"
   Exclude:
     - "**/*.rake"
+    - "lib/**/*.rb"
+
+Sorbet/StrictSigil:
+  Enabled: true
+  Include:
+    - "lib/**/*.rb"
+  Exclude:
+    - "**/*.rake"
+    - "test/**/*.rb"
+    - "lib/ruby-lsp.rb"

data/CHANGELOG.md

@@ -6,6 +6,41 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+## [0.2.1]
+
+- Implement the exit lifecycle request (https://github.com/Shopify/ruby-lsp/pull/198)
+- Remove the Sorbet runtime from the gem's default load path (https://github.com/Shopify/ruby-lsp/pull/214)
+- Return nil if the document is already formatted (https://github.com/Shopify/ruby-lsp/pull/216)
+- Handle nameless keyword rest parameters in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/222)
+- Display a warning on invalid RuboCop configuration (https://github.com/Shopify/ruby-lsp/pull/226)
+- Centralize request handling logic in server.rb (https://github.com/Shopify/ruby-lsp/pull/221)
+- Fix folding ranges for chained invocations involving an FCall (https://github.com/Shopify/ruby-lsp/pull/223)
+- Fix handling of argument fowarding in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/228)
+- Recover from initial syntax errors when opening documents (https://github.com/Shopify/ruby-lsp/pull/224)
+- Highlight occurrences and definitions in document highlight (https://github.com/Shopify/ruby-lsp/pull/187)
+
+## [0.2.0]
+
+- Add semantic token for keyword and keyword rest params (https://github.com/Shopify/ruby-lsp/pull/142)
+- Return error responses on exceptions (https://github.com/Shopify/ruby-lsp/pull/160)
+- Sanitize home directory for telemetry (https://github.com/Shopify/ruby-lsp/pull/171)
+- Avoid adding semantic tokens for special methods (https://github.com/Shopify/ruby-lsp/pull/162)
+- Properly respect excluded files in RuboCop requests (https://github.com/Shopify/ruby-lsp/pull/173)
+- Clear diagnostics when closing files (https://github.com/Shopify/ruby-lsp/pull/174)
+- Avoid pushing ranges for single line partial ranges (https://github.com/Shopify/ruby-lsp/pull/185)
+- Change folding ranges to include closing tokens (https://github.com/Shopify/ruby-lsp/pull/181)
+- Remove RuboCop dependency and fallback to SyntaxTree formatting (https://github.com/Shopify/ruby-lsp/pull/184)
+
+## [0.1.0]
+
+- Implement token modifiers in SemanticTokenEncoder ([#112](https://github.com/Shopify/ruby-lsp/pull/112))
+- Add semantic token for name in a method definition ([#133](https://github.com/Shopify/ruby-lsp/pull/133))
+- Add semantic highighting for def endless and singleton method names ([#134](https://github.com/Shopify/ruby-lsp/pull/134))
+- Add semantic token for keyword self ([#137](https://github.com/Shopify/ruby-lsp/pull/137))
+- Add semantic token for constants ([#138](https://github.com/Shopify/ruby-lsp/pull/138))
+- Improve error handling + fix formatting hanging issue ([#149](https://github.com/Shopify/ruby-lsp/pull/149))
+- Set the minimum syntax_tree version to 2.4 ([#151](https://github.com/Shopify/ruby-lsp/pull/151))
+
 ## [0.0.4]
 
 - Add basic document highlight (https://github.com/Shopify/ruby-lsp/pull/91)

data/Gemfile

@@ -5,11 +5,12 @@ source "https://rubygems.org"
 gemspec
 
 gem "debug", "~> 1.5", require: false
-gem "minitest", "~> 5.15"
+gem "minitest", "~> 5.16"
 gem "minitest-reporters", "~> 1.5"
 gem "rake", "~> 13.0"
-gem "rubocop-shopify", "~> 2.7", require: false
-gem "rubocop-minitest", "~> 0.20.0", require: false
+gem "rubocop", ">= 1.0.0"
+gem "rubocop-shopify", "~> 2.8", require: false
+gem "rubocop-minitest", "~> 0.20.1", require: false
 gem "rubocop-rake", "~> 0.6.0", require: false
 gem "rubocop-sorbet", "~> 0.6", require: false
 gem "sorbet-static-and-runtime"

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    ruby-lsp (0.0.4)
+    ruby-lsp (0.2.1)
       language_server-protocol
-      rubocop (>= 1.0)
       sorbet-runtime
-      syntax_tree (>= 2.3)
+      syntax_tree (>= 2.4)
 
 GEM
   remote: https://rubygems.org/
@@ -21,9 +20,10 @@ GEM
     io-console (0.5.11)
     irb (1.4.1)
       reline (>= 0.3.0)
+    json (2.6.2)
     language_server-protocol (3.16.0.3)
     method_source (1.0.0)
-    minitest (5.15.0)
+    minitest (5.16.2)
     minitest-reporters (1.5.0)
       ansi
       builder
@@ -38,7 +38,7 @@ GEM
       method_source (~> 1.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    rbi (0.0.14)
+    rbi (0.0.15)
       ast
       parser (>= 2.6.4.0)
       sorbet-runtime (>= 0.5.9204)
@@ -47,7 +47,8 @@ GEM
     reline (0.3.1)
       io-console (~> 0.5)
     rexml (3.2.5)
-    rubocop (1.30.0)
+    rubocop (1.31.1)
+      json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
@@ -58,30 +59,30 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
-    rubocop-minitest (0.20.0)
+    rubocop-minitest (0.20.1)
       rubocop (>= 0.90, < 2.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-shopify (2.7.0)
-      rubocop (~> 1.30)
-    rubocop-sorbet (0.6.8)
+    rubocop-shopify (2.8.0)
+      rubocop (~> 1.31)
+    rubocop-sorbet (0.6.11)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.11.0)
-    sorbet (0.5.10073)
-      sorbet-static (= 0.5.10073)
-    sorbet-runtime (0.5.10073)
-    sorbet-static (0.5.10073-universal-darwin-21)
-    sorbet-static (0.5.10073-x86_64-linux)
-    sorbet-static-and-runtime (0.5.10073)
-      sorbet (= 0.5.10073)
-      sorbet-runtime (= 0.5.10073)
+    sorbet (0.5.10139)
+      sorbet-static (= 0.5.10139)
+    sorbet-runtime (0.5.10139)
+    sorbet-static (0.5.10139-universal-darwin-21)
+    sorbet-static (0.5.10139-x86_64-linux)
+    sorbet-static-and-runtime (0.5.10139)
+      sorbet (= 0.5.10139)
+      sorbet-runtime (= 0.5.10139)
     spoom (1.1.11)
       sorbet (>= 0.5.9204)
       sorbet-runtime (>= 0.5.9204)
       thor (>= 0.19.2)
-    syntax_tree (2.7.1)
+    syntax_tree (2.8.0)
       prettier_print
-    tapioca (0.8.1)
+    tapioca (0.8.3)
       bundler (>= 1.17.3)
       parallel (>= 1.21.0)
       pry (>= 0.12.2)
@@ -91,7 +92,7 @@ GEM
       thor (>= 1.2.0)
       yard-sorbet
     thor (1.2.1)
-    unicode-display_width (2.1.0)
+    unicode-display_width (2.2.0)
     unparser (0.6.5)
       diff-lcs (~> 1.3)
       parser (>= 3.1.0)
@@ -108,12 +109,13 @@ PLATFORMS
 
 DEPENDENCIES
   debug (~> 1.5)
-  minitest (~> 5.15)
+  minitest (~> 5.16)
   minitest-reporters (~> 1.5)
   rake (~> 13.0)
-  rubocop-minitest (~> 0.20.0)
+  rubocop (>= 1.0.0)
+  rubocop-minitest (~> 0.20.1)
   rubocop-rake (~> 0.6.0)
-  rubocop-shopify (~> 2.7)
+  rubocop-shopify (~> 2.8)
   rubocop-sorbet (~> 0.6)
   ruby-lsp!
   sorbet-static-and-runtime

data/README.md

@@ -17,7 +17,8 @@ end
 If using VS Code, install the [Ruby LSP plugin](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
 the editor.
 
-See the [documentation](https://shopify.github.io/ruby-lsp) for supported features.
+See the [documentation](https://shopify.github.io/ruby-lsp) for
+[supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
 ## Contributing
 
@@ -50,7 +51,7 @@ To add a new expectations test runner for a new request handler:
    require "expectations/expectations_test_runner"
 
    class $HANDLERExpectationsTest < ExpectationsTestRunner
-    expectations_tests RubyLsp::Requests::$HANDLER, "$EXPECTATIONS_DIR"
+     expectations_tests RubyLsp::Requests::$HANDLER, "$EXPECTATIONS_DIR"
    end
    ```
 

data/Rakefile

@@ -11,7 +11,14 @@ Rake::TestTask.new(:test) do |t|
 end
 
 YARD::Rake::YardocTask.new do |t|
-  t.options = ["--markup", "markdown", "--output-dir", "docs"]
+  t.options = [
+    "--markup",
+    "markdown",
+    "--output-dir",
+    "docs",
+    "--asset",
+    "misc",
+  ]
 end
 
 require "rubocop/rake_task"

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.2.1

data/bin/console

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# typed: strict
+# frozen_string_literal: true
+
+require "bundler/setup"
+require_relative "../lib/ruby_lsp/internal"
+require "irb"
+
+extend T::Sig
+
+sig { params(source: String).returns(RubyLsp::Document) }
+def new_doc(source)
+  RubyLsp::Document.new(source)
+end
+
+@source = T.let(File.read(File.expand_path("../lib/ruby_lsp/handler.rb", __dir__)), String)
+@document = T.let(new_doc(@source), RubyLsp::Document)
+
+IRB.start(__FILE__)

data/exe/ruby-lsp

@@ -18,6 +18,4 @@ rescue
   nil
 end
 
-require_relative "../lib/internal"
-
-RubyLsp::Cli.start
+require_relative "../lib/ruby_lsp/server"

data/lib/ruby_lsp/document.rb

@@ -9,7 +9,7 @@ module RubyLsp
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
     EditShape = T.type_alias { { range: RangeShape, text: String } }
 
-    sig { returns(SyntaxTree::Node) }
+    sig { returns(T.nilable(SyntaxTree::Node)) }
     attr_reader :tree
 
     sig { returns(String) }
@@ -20,11 +20,13 @@ module RubyLsp
 
     sig { params(source: String).void }
     def initialize(source)
-      @tree = T.let(SyntaxTree.parse(source), SyntaxTree::Node)
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @syntax_error_edits = T.let([], T::Array[EditShape])
-      @source = source
+      @source = T.let(source, String)
       @parsable_source = T.let(source.dup, String)
+      @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
+    rescue SyntaxTree::Parser::ParseError
+      # Do not raise if we failed to parse
     end
 
     sig { params(other: Document).returns(T::Boolean) }
@@ -32,7 +34,13 @@ module RubyLsp
       @source == other.source
     end
 
-    sig { params(request_name: Symbol, block: T.proc.params(document: Document).returns(T.untyped)).returns(T.untyped) }
+    sig do
+      type_parameters(:T)
+        .params(
+          request_name: Symbol,
+          block: T.proc.params(document: Document).returns(T.type_parameter(:T))
+        ).returns(T.type_parameter(:T))
+    end
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
       return cached if cached
@@ -61,6 +69,11 @@ module RubyLsp
       @syntax_error_edits.any?
     end
 
+    sig { returns(T::Boolean) }
+    def parsed?
+      !@tree.nil?
+    end
+
     private
 
     sig { params(edits: T::Array[EditShape]).void }

data/lib/ruby_lsp/handler.rb

@@ -6,17 +6,24 @@ require "ruby_lsp/store"
 require "benchmark"
 
 module RubyLsp
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+  Transport = LanguageServer::Protocol::Transport
+
   class Handler
     extend T::Sig
     VOID = T.let(Object.new.freeze, Object)
 
+    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
+    def self.start(&blk)
+      handler = new
+      handler.instance_exec(&blk)
+      handler.start
+    end
+
     sig { returns(Store) }
     attr_reader :store
 
-    Interface = LanguageServer::Protocol::Interface
-    Constant = LanguageServer::Protocol::Constant
-    Transport = LanguageServer::Protocol::Transport
-
     sig { void }
     def initialize
       @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
@@ -28,14 +35,7 @@ module RubyLsp
     sig { void }
     def start
       $stderr.puts "Starting Ruby LSP..."
-      @reader.read do |request|
-        with_telemetry(request) { handle(request) }
-      end
-    end
-
-    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
-    def config(&blk)
-      instance_exec(&blk)
+      @reader.read { |request| handle(request) }
     end
 
     private
@@ -52,11 +52,32 @@ module RubyLsp
 
     sig { params(request: T::Hash[Symbol, T.untyped]).void }
     def handle(request)
+      result = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
       handler = @handlers[request[:method]]
-      return unless handler
 
-      result = handler.call(request)
-      @writer.write(id: request[:id], result: result) unless result == VOID
+      request_time = Benchmark.realtime do
+        if handler
+          begin
+            result = handler.call(request)
+          rescue StandardError => e
+            error = e
+          end
+
+          if error
+            @writer.write(
+              {
+                id: request[:id],
+                error: { code: Constant::ErrorCodes::INTERNAL_ERROR, message: error.inspect, data: request.to_json },
+              }
+            )
+          elsif result != VOID
+            @writer.write(id: request[:id], result: result)
+          end
+        end
+      end
+
+      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
     end
 
     sig { void }
@@ -65,106 +86,14 @@ module RubyLsp
       store.clear
     end
 
-    sig { params(enabled_features: T::Array[String]).returns(Interface::InitializeResult) }
-    def respond_with_capabilities(enabled_features)
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
-          }
-        )
-      end
-
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys
-          ),
-          range: false,
-          full: {
-            delta: true,
-          }
-        )
-      end
-
-      Interface::InitializeResult.new(
-        capabilities: Interface::ServerCapabilities.new(
-          text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::INCREMENTAL,
-            open_close: true,
-          ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
-          document_symbol_provider: document_symbol_provider,
-          folding_range_provider: folding_ranges_provider,
-          semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features.include?("formatting"),
-          document_highlight_provider: enabled_features.include?("documentHighlights"),
-          code_action_provider: enabled_features.include?("codeActions")
-        )
-      )
-    end
-
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
-    def respond_with_document_symbol(uri)
-      store.cache_fetch(uri, :document_symbol) do |document|
-        RubyLsp::Requests::DocumentSymbol.run(document)
-      end
-    end
-
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::FoldingRange]) }
-    def respond_with_folding_ranges(uri)
-      store.cache_fetch(uri, :folding_ranges) do |document|
-        Requests::FoldingRanges.run(document)
-      end
-    end
-
-    sig do
-      params(
-        uri: String,
-        positions: T::Array[Document::PositionShape]
-      ).returns(T::Array[RubyLsp::Requests::Support::SelectionRange])
-    end
-    def respond_with_selection_ranges(uri, positions)
-      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.run(document)
-      end
-
-      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
-      # every position in the positions array should have an element at the same index in the response
-      # array. For positions without a valid selection range, the corresponding element in the response
-      # array will be nil.
-      positions.map do |position|
-        ranges.find do |range|
-          range.cover?(position)
-        end
-      end
-    end
-
-    sig { params(uri: String).returns(LanguageServer::Protocol::Interface::SemanticTokens) }
-    def respond_with_semantic_highlighting(uri)
-      store.cache_fetch(uri, :semantic_highlighting) do |document|
-        Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run
-      end
-    end
-
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
-    def respond_with_formatting(uri)
-      Requests::Formatting.run(uri, store.get(uri))
-    end
-
     sig { params(uri: String).void }
     def send_diagnostics(uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.run(uri, document)
+        Requests::Diagnostics.new(uri, document).run
       end
 
+      return if response.nil?
+
       @writer.write(
         method: "textDocument/publishDiagnostics",
         params: Interface::PublishDiagnosticsParams.new(
@@ -172,40 +101,24 @@ module RubyLsp
           diagnostics: response.map(&:to_lsp_diagnostic)
         )
       )
+    rescue RuboCop::ValidationError => e
+      show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{e.message}")
     end
 
-    sig do
-      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::Diagnostic])
-    end
-    def respond_with_code_actions(uri, range)
-      store.cache_fetch(uri, :code_actions) do |document|
-        Requests::CodeActions.run(uri, document, range)
-      end
-    end
-
-    sig do
-      params(
-        uri: String,
-        position: Document::PositionShape
-      ).returns(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
-    end
-    def respond_with_document_highlight(uri, position)
-      Requests::DocumentHighlight.run(store.get(uri), position)
+    sig { params(uri: String).void }
+    def clear_diagnostics(uri)
+      @writer.write(
+        method: "textDocument/publishDiagnostics",
+        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: [])
+      )
     end
 
-    sig { params(request: T::Hash[Symbol, T.untyped], block: T.proc.void).returns(T.untyped) }
-    def with_telemetry(request, &block)
-      result = T.let(nil, T.untyped)
-      error = T.let(nil, T.nilable(StandardError))
-
-      request_time = Benchmark.realtime do
-        result = block.call
-      rescue StandardError => e
-        error = e
-      end
-
-      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
-      result
+    sig { params(type: Integer, message: String).void }
+    def show_message(type, message)
+      @writer.write(
+        method: "window/showMessage",
+        params: Interface::ShowMessageParams.new(type: type, message: message)
+      )
     end
 
     sig do
@@ -229,7 +142,7 @@ module RubyLsp
         params[:errorMessage] = error.message
       end
 
-      params[:uri] = uri if uri
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
       params
     end
   end

data/lib/{internal.rb → ruby_lsp/internal.rb}

@@ -1,7 +1,9 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"
 require "syntax_tree"
+require "language_server-protocol"
+
 require "ruby-lsp"
-require "ruby_lsp/cli"
+require "ruby_lsp/handler"

data/lib/ruby_lsp/requests/base_request.rb

@@ -1,24 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     # :nodoc:
     class BaseRequest < SyntaxTree::Visitor
-      def self.run(document)
-        new(document).run
-      end
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
 
+      sig { params(document: Document).void }
       def initialize(document)
         @document = document
 
         super()
       end
 
-      def run
-        raise NotImplementedError, "#{self.class}#run must be implemented"
-      end
+      sig { abstract.returns(Object) }
+      def run; end
 
+      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
       def range_from_syntax_tree_node(node)
         loc = node.location
 

data/lib/ruby_lsp/requests/code_actions.rb

@@ -1,8 +1,10 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Code actions demo](../../misc/code_actions.gif)
+    #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accesible by hovering over a
     # specific diagnostic.
@@ -14,23 +16,32 @@ module RubyLsp
     # puts "Hello" # --> code action: quick fix indentation
     # end
     # ```
-    class CodeActions
-      def self.run(uri, document, range)
-        new(uri, document, range).run
-      end
+    class CodeActions < BaseRequest
+      extend T::Sig
 
+      sig do
+        params(
+          uri: String,
+          document: Document,
+          range: T::Range[Integer]
+        ).void
+      end
       def initialize(uri, document, range)
-        @document = document
+        super(document)
+
         @uri = uri
         @range = range
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
       def run
-        diagnostics = Diagnostics.run(@uri, @document)
-        corrections = diagnostics.select { |diagnostic| diagnostic.correctable? && diagnostic.in_range?(@range) }
+        diagnostics = Diagnostics.new(@uri, @document).run
+        corrections = diagnostics.select do |diagnostic|
+          diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
+        end
         return [] if corrections.empty?
 
-        corrections.map!(&:to_lsp_code_action)
+        T.cast(corrections, T::Array[Support::RuboCopDiagnostic]).map!(&:to_lsp_code_action)
       end
     end
   end