ruby-lsp 0.23.1 → 0.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4a7b6b44dae357ccbc6a9f6494bd892d890bebf1287aa6c989ef4f2aee14e82
-  data.tar.gz: cbfc554b33a2cf45663ab394e4fb81e27eb2ec4309907943e3fe67d591222d63
+  metadata.gz: 95642b8034d20684e2596755f391591d6dfffc9021e23a6e2efd0b9a0e500eb0
+  data.tar.gz: 6db469fda24144ce71eb0c2d8434251b3bf01a800035d85bea5e8e6801cf5120
 SHA512:
-  metadata.gz: bee0f714bd2f2865eeefa2de4eeb2f31bbf55d1fb106cb2a19af208bfc8c868815e2fcad86dcd58a119c9494c6a8254b01fcacdbeb02ce4379a8242ad94d2fcb
-  data.tar.gz: 690d71bce5781f0de3ff170782d76e1d6ef34afd6801525c9ebbb92cfc64c2b9adc25b591710eaf4100c138706a8a358bfe6959d133a0da96e7cdd16279549c7
+  metadata.gz: 69365797e36c6597b43b5067da2e10b6c634cdb9121081db0e7c16c657fe12e2aa72042ba7beb07480b1cbb4a24c9a37a7a71f5a49a1be42923adb7a85a80715
+  data.tar.gz: 22695e4a4fd4e72738b43c32e9a693ed9895033e82240317700cde5583537b0ad6e7d8ce530a110624c57278d5a08c4eeb207ae010a4db99b3885bc241c5caa4

data/VERSION

@@ -1 +1 @@
-0.23.1
+0.23.3

data/exe/ruby-lsp-launcher

@@ -45,6 +45,12 @@ rescue Errno::ECHILD
   # In theory, the child process can finish before we even get to the wait call, but that is not an error
 end
 
+error_path = File.join(".ruby-lsp", "install_error")
+
+install_error = if File.exist?(error_path)
+  Marshal.load(File.read(error_path))
+end
+
 begin
   bundle_env_path = File.join(".ruby-lsp", "bundle_env")
   # We can't require `bundler/setup` because that file prematurely exits the process if setup fails. However, we can't
@@ -67,21 +73,21 @@ begin
 rescue StandardError => e
   # If installing gems failed for any reason, we don't want to exit the process prematurely. We can still provide most
   # features in a degraded mode. We simply save the error so that we can report to the user that certain gems might be
-  # missing, but we respect the LSP life cycle
-  setup_error = e
-  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  # missing, but we respect the LSP life cycle.
+  #
+  # If an install error occurred and one of the gems is not installed, Bundler.setup is guaranteed to fail with
+  # `Bundler::GemNotFound`. We don't set `setup_error` here because that would essentially report the same problem twice
+  # to telemetry, which is not useful
+  unless install_error && e.is_a?(Bundler::GemNotFound)
+    setup_error = e
+    $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  end
 
   # If Bundler.setup fails, we need to restore the original $LOAD_PATH so that we can still require the Ruby LSP server
   # in degraded mode
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 end
 
-error_path = File.join(".ruby-lsp", "install_error")
-
-install_error = if File.exist?(error_path)
-  Marshal.load(File.read(error_path))
-end
-
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -24,7 +24,7 @@ module RubyIndexer
       @index = index
       @uri = uri
       @enhancements = T.let(Enhancement.all(self), T::Array[Enhancement])
-      @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
+      @visibility_stack = T.let([VisibilityScope.public_scope], T::Array[VisibilityScope])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
           [c.location.start_line, c]
@@ -64,7 +64,6 @@ module RubyIndexer
         :on_constant_path_or_write_node_enter,
         :on_constant_path_operator_write_node_enter,
         :on_constant_path_and_write_node_enter,
-        :on_constant_or_write_node_enter,
         :on_constant_write_node_enter,
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
@@ -138,7 +137,7 @@ module RubyIndexer
 
     sig { params(node: Prism::SingletonClassNode).void }
     def on_singleton_class_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @visibility_stack.push(VisibilityScope.public_scope)
 
       current_owner = @owner_stack.last
 
@@ -280,15 +279,14 @@ module RubyIndexer
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
-        @visibility_stack.push(Entry::Visibility::PUBLIC)
+        @visibility_stack.push(VisibilityScope.public_scope)
       when :protected
-        @visibility_stack.push(Entry::Visibility::PROTECTED)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PROTECTED))
       when :private
-        @visibility_stack.push(Entry::Visibility::PRIVATE)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
       when :module_function
         handle_module_function(node)
       when :private_class_method
-        @visibility_stack.push(Entry::Visibility::PRIVATE)
         handle_private_class_method(node)
       end
 
@@ -324,42 +322,61 @@ module RubyIndexer
 
     sig { params(node: Prism::DefNode).void }
     def on_def_node_enter(node)
+      owner = @owner_stack.last
+      return unless owner
+
       @inside_def = true
       method_name = node.name.to_s
       comments = collect_comments(node)
+      scope = current_visibility_scope
 
       case node.receiver
       when nil
+        location = Location.from_prism_location(node.location, @code_units_cache)
+        name_location = Location.from_prism_location(node.name_loc, @code_units_cache)
+        signatures = [Entry::Signature.new(list_params(node.parameters))]
+
         @index.add(Entry::Method.new(
           method_name,
           @uri,
-          Location.from_prism_location(node.location, @code_units_cache),
-          Location.from_prism_location(node.name_loc, @code_units_cache),
+          location,
+          name_location,
           comments,
-          [Entry::Signature.new(list_params(node.parameters))],
-          current_visibility,
-          @owner_stack.last,
+          signatures,
+          scope.visibility,
+          owner,
         ))
-      when Prism::SelfNode
-        owner = @owner_stack.last
 
-        if owner
+        if scope.module_func
           singleton = @index.existing_or_new_singleton_class(owner.name)
 
           @index.add(Entry::Method.new(
             method_name,
             @uri,
-            Location.from_prism_location(node.location, @code_units_cache),
-            Location.from_prism_location(node.name_loc, @code_units_cache),
+            location,
+            name_location,
             comments,
-            [Entry::Signature.new(list_params(node.parameters))],
-            current_visibility,
+            signatures,
+            Entry::Visibility::PUBLIC,
             singleton,
           ))
-
-          @owner_stack << singleton
-          @stack << "<Class:#{@stack.last}>"
         end
+      when Prism::SelfNode
+        singleton = @index.existing_or_new_singleton_class(owner.name)
+
+        @index.add(Entry::Method.new(
+          method_name,
+          @uri,
+          Location.from_prism_location(node.location, @code_units_cache),
+          Location.from_prism_location(node.name_loc, @code_units_cache),
+          comments,
+          [Entry::Signature.new(list_params(node.parameters))],
+          scope.visibility,
+          singleton,
+        ))
+
+        @owner_stack << singleton
+        @stack << "<Class:#{@stack.last}>"
       end
     end
 
@@ -834,6 +851,8 @@ module RubyIndexer
       return unless receiver.nil? || receiver.is_a?(Prism::SelfNode)
 
       comments = collect_comments(node)
+      scope = current_visibility_scope
+
       arguments.each do |argument|
         name, loc = case argument
         when Prism::SymbolNode
@@ -850,7 +869,7 @@ module RubyIndexer
             @uri,
             Location.from_prism_location(loc, @code_units_cache),
             comments,
-            current_visibility,
+            scope.visibility,
             @owner_stack.last,
           ))
         end
@@ -862,7 +881,7 @@ module RubyIndexer
           @uri,
           Location.from_prism_location(loc, @code_units_cache),
           comments,
-          current_visibility,
+          scope.visibility,
           @owner_stack.last,
         ))
       end
@@ -904,11 +923,20 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_module_function(node)
+      # Invoking `module_function` in a class raises
+      owner = @owner_stack.last
+      return unless owner.is_a?(Entry::Module)
+
       arguments_node = node.arguments
-      return unless arguments_node
 
-      owner_name = @owner_stack.last&.name
-      return unless owner_name
+      # If `module_function` is invoked without arguments, all methods defined after it become singleton methods and the
+      # visibility for instance methods changes to private
+      unless arguments_node
+        @visibility_stack.push(VisibilityScope.module_function_scope)
+        return
+      end
+
+      owner_name = owner.name
 
       arguments_node.arguments.each do |argument|
         method_name = case argument
@@ -946,45 +974,48 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_private_class_method(node)
-      node.arguments&.arguments&.each do |argument|
-        string_or_symbol_nodes = case argument
-        when Prism::StringNode, Prism::SymbolNode
-          [argument]
-        when Prism::ArrayNode
-          argument.elements
-        else
-          []
-        end
+      arguments = node.arguments&.arguments
+      return unless arguments
 
-        unless string_or_symbol_nodes.empty?
-          # pop the visibility off since there isn't a method definition following `private_class_method`
-          @visibility_stack.pop
-        end
+      # If we're passing a method definition directly to `private_class_method`, push a new private scope. That will be
+      # applied when the indexer finds the method definition and then popped on `call_node_leave`
+      if arguments.first.is_a?(Prism::DefNode)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        return
+      end
 
-        string_or_symbol_nodes.each do |string_or_symbol_node|
-          method_name = case string_or_symbol_node
-          when Prism::StringNode
-            string_or_symbol_node.content
-          when Prism::SymbolNode
-            string_or_symbol_node.value
-          end
-          next unless method_name
+      owner_name = @owner_stack.last&.name
+      return unless owner_name
 
-          owner_name = @owner_stack.last&.name
-          next unless owner_name
+      # private_class_method accepts strings, symbols or arrays of strings and symbols as arguments. Here we build a
+      # single list of all of the method names that have to be made private
+      arrays, others = T.cast(
+        arguments.partition { |argument| argument.is_a?(Prism::ArrayNode) },
+        [T::Array[Prism::ArrayNode], T::Array[Prism::Node]],
+      )
+      arrays.each { |array| others.concat(array.elements) }
 
-          entries = @index.resolve_method(method_name, @index.existing_or_new_singleton_class(owner_name).name)
-          next unless entries
+      names = others.filter_map do |argument|
+        case argument
+        when Prism::StringNode
+          argument.unescaped
+        when Prism::SymbolNode
+          argument.value
+        end
+      end
 
-          entries.each do |entry|
-            entry.visibility = Entry::Visibility::PRIVATE
-          end
+      names.each do |name|
+        entries = @index.resolve_method(name, @index.existing_or_new_singleton_class(owner_name).name)
+        next unless entries
+
+        entries.each do |entry|
+          entry.visibility = Entry::Visibility::PRIVATE
         end
       end
     end
 
-    sig { returns(Entry::Visibility) }
-    def current_visibility
+    sig { returns(VisibilityScope) }
+    def current_visibility_scope
       T.must(@visibility_stack.last)
     end
 
@@ -1091,7 +1122,7 @@ module RubyIndexer
 
     sig { params(short_name: String, entry: Entry::Namespace).void }
     def advance_namespace_stack(short_name, entry)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @visibility_stack.push(VisibilityScope.public_scope)
       @owner_stack << entry
       @index.add(entry)
       @stack << short_name

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -48,6 +48,8 @@ module RubyIndexer
       )
 
       @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
+
+      @initial_indexing_completed = T.let(false, T::Boolean)
     end
 
     # Register an included `hook` that will be executed when `module_name` is included into any namespace
@@ -56,8 +58,8 @@ module RubyIndexer
       (@included_hooks[module_name] ||= []) << hook
     end
 
-    sig { params(uri: URI::Generic).void }
-    def delete(uri)
+    sig { params(uri: URI::Generic, skip_require_paths_tree: T::Boolean).void }
+    def delete(uri, skip_require_paths_tree: false)
       key = uri.to_s
       # For each constant discovered in `path`, delete the associated entry from the index. If there are no entries
       # left, delete the constant from the index.
@@ -80,6 +82,7 @@ module RubyIndexer
       end
 
       @uris_to_entries.delete(key)
+      return if skip_require_paths_tree
 
       require_path = uri.require_path
       @require_paths_tree.delete(require_path) if require_path
@@ -357,12 +360,13 @@ module RubyIndexer
       # When troubleshooting an indexing issue, e.g. through irb, it's not obvious that `index_all` will augment the
       # existing index values, meaning it may contain 'stale' entries. This check ensures that the user is aware of this
       # behavior and can take appropriate action.
-      # binding.break
-      if @entries.any?
+      if @initial_indexing_completed
         raise IndexNotEmptyError,
           "The index is not empty. To prevent invalid entries, `index_all` can only be called once."
       end
 
+      @initial_indexing_completed = true
+
       RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
       progress_step = (uris.length / 100.0).ceil
@@ -618,17 +622,24 @@ module RubyIndexer
     end
 
     # Synchronizes a change made to the given URI. This method will ensure that new declarations are indexed, removed
-    # declarations removed and that the ancestor linearization cache is cleared if necessary
-    sig { params(uri: URI::Generic, source: String).void }
-    def handle_change(uri, source)
+    # declarations removed and that the ancestor linearization cache is cleared if necessary. If a block is passed, the
+    # consumer of this API has to handle deleting and inserting/updating entries in the index instead of passing the
+    # document's source (used to handle unsaved changes to files)
+    sig do
+      params(uri: URI::Generic, source: T.nilable(String), block: T.nilable(T.proc.params(index: Index).void)).void
+    end
+    def handle_change(uri, source = nil, &block)
       key = uri.to_s
       original_entries = @uris_to_entries[key]
 
-      delete(uri)
-      index_single(uri, source)
+      if block
+        block.call(self)
+      else
+        delete(uri)
+        index_single(uri, T.must(source))
+      end
 
       updated_entries = @uris_to_entries[key]
-
       return unless original_entries && updated_entries
 
       # A change in one ancestor may impact several different others, which could be including that ancestor through

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  # Represents the visibility scope in a Ruby namespace. This keeps track of whether methods are in a public, private or
+  # protected section, and whether they are module functions.
+  class VisibilityScope
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T.attached_class) }
+      def module_function_scope
+        new(module_func: true, visibility: Entry::Visibility::PRIVATE)
+      end
+
+      sig { returns(T.attached_class) }
+      def public_scope
+        new
+      end
+    end
+
+    sig { returns(Entry::Visibility) }
+    attr_reader :visibility
+
+    sig { returns(T::Boolean) }
+    attr_reader :module_func
+
+    sig { params(visibility: Entry::Visibility, module_func: T::Boolean).void }
+    def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
+      @visibility = visibility
+      @module_func = module_func
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,6 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/uri"
+require "ruby_indexer/lib/ruby_indexer/visibility_scope"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
 require "ruby_indexer/lib/ruby_indexer/reference_finder"
 require "ruby_indexer/lib/ruby_indexer/enhancement"

data/lib/ruby_indexer/test/index_test.rb

@@ -2061,7 +2061,8 @@ module RubyIndexer
     end
 
     def test_prevents_multiple_calls_to_index_all
-      # For this test class, `index_all` is already called once in `setup`.
+      @index.index_all
+
       assert_raises(Index::IndexNotEmptyError) do
         @index.index_all
       end

data/lib/ruby_indexer/test/instance_variables_test.rb

@@ -216,5 +216,25 @@ module RubyIndexer
       assert_instance_of(Entry::Class, owner)
       assert_equal("Foo", owner.name)
     end
+
+    def test_module_function_does_not_impact_instance_variables
+      # One possible way of implementing `module_function` would be to push a fake singleton class to the stack, so that
+      # methods are inserted into it. However, that would be incorrect because it would then bind instance variables to
+      # the wrong type. This test is here to prevent that from happening.
+      index(<<~RUBY)
+        module Foo
+          module_function
+
+          def something; end
+
+          @a = 123
+        end
+      RUBY
+
+      entry = T.must(@index["@a"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::SingletonClass, owner)
+      assert_equal("Foo::<Class:Foo>", owner.name)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -88,19 +88,21 @@ module RubyIndexer
 
     def test_visibility_tracking
       index(<<~RUBY)
-        private def foo
-        end
+        class Foo
+          private def foo
+          end
 
-        def bar; end
+          def bar; end
 
-        protected
+          protected
 
-        def baz; end
+          def baz; end
+        end
       RUBY
 
-      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:0-8:1-3", visibility: Entry::Visibility::PRIVATE)
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:3-0:3-12", visibility: Entry::Visibility::PUBLIC)
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:7-0:7-12", visibility: Entry::Visibility::PROTECTED)
+      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:1-10:2-5", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:4-2:4-14", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:8-2:8-14", visibility: Entry::Visibility::PROTECTED)
     end
 
     def test_visibility_tracking_with_nested_class_or_modules
@@ -846,6 +848,82 @@ module RubyIndexer
       assert_signature_matches(entry, "baz(1)")
     end
 
+    def test_module_function_with_no_arguments
+      index(<<~RUBY)
+        module Foo
+          def bar; end
+
+          module_function
+
+          def baz; end
+          attr_reader :attribute
+
+          public
+
+          def qux; end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      instance_baz, singleton_baz = T.must(@index["baz"])
+      assert_predicate(instance_baz, :private?)
+      assert_equal("Foo", T.must(instance_baz.owner).name)
+
+      assert_predicate(singleton_baz, :public?)
+      assert_equal("Foo::<Class:Foo>", T.must(singleton_baz.owner).name)
+
+      # After invoking `public`, the state of `module_function` is reset
+      instance_qux, singleton_qux = T.must(@index["qux"])
+      assert_nil(singleton_qux)
+      assert_predicate(instance_qux, :public?)
+      assert_equal("Foo", T.must(instance_baz.owner).name)
+
+      # Attributes are not turned into class methods, they do become private
+      instance_attribute, singleton_attribute = @index["attribute"]
+      assert_nil(singleton_attribute)
+      assert_equal("Foo", T.must(instance_attribute.owner).name)
+      assert_predicate(instance_attribute, :private?)
+    end
+
+    def test_module_function_does_nothing_in_classes
+      # Invoking `module_function` in a class raises an error. We simply ignore it
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+
+          module_function
+
+          def baz; end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      entry = T.must(@index["baz"].first)
+      assert_predicate(entry, :public?)
+      assert_equal("Foo", T.must(entry.owner).name)
+    end
+
+    def test_making_several_class_methods_private
+      index(<<~RUBY)
+        class Foo
+          def self.bar; end
+          def self.baz; end
+          def self.qux; end
+
+          private_class_method :bar, :baz, :qux
+
+          def initialize
+          end
+        end
+      RUBY
+    end
+
     private
 
     sig { params(entry: Entry::Method, call_string: String).void }

data/lib/ruby_lsp/base_server.rb

@@ -18,22 +18,21 @@ module RubyLsp
       @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
       @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
       @cancelled_requests = T.let([], T::Array[Integer])
-      @mutex = T.let(Mutex.new, Mutex)
       @worker = T.let(new_worker, Thread)
       @current_request_id = T.let(1, Integer)
-      @store = T.let(Store.new, Store)
+      @global_state = T.let(GlobalState.new, GlobalState)
+      @store = T.let(Store.new(@global_state), Store)
       @outgoing_dispatcher = T.let(
         Thread.new do
           unless @test_mode
             while (message = @outgoing_queue.pop)
-              @mutex.synchronize { @writer.write(message.to_hash) }
+              @global_state.synchronize { @writer.write(message.to_hash) }
             end
           end
         end,
         Thread,
       )
 
-      @global_state = T.let(GlobalState.new, GlobalState)
       Thread.main.priority = 1
 
       # We read the initialize request in `exe/ruby-lsp` to be able to determine the workspace URI where Bundler should
@@ -51,7 +50,7 @@ module RubyLsp
         # source. Altering the source reference during parsing will put the parser in an invalid internal state, since
         # it started parsing with one source but then it changed in the middle. We don't want to do this for text
         # synchronization notifications
-        @mutex.synchronize do
+        @global_state.synchronize do
           uri = message.dig(:params, :textDocument, :uri)
 
           if uri
@@ -91,18 +90,17 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-             "$/cancelRequest"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           process_message(message)
         when "shutdown"
-          @mutex.synchronize do
+          @global_state.synchronize do
             send_log_message("Shutting down Ruby LSP...")
             shutdown
             run_shutdown
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @mutex.synchronize do
+          @global_state.synchronize do
             status = @incoming_queue.closed? ? 0 : 1
             send_log_message("Shutdown complete with status #{status}")
             exit(status)
@@ -157,13 +155,9 @@ module RubyLsp
           id = message[:id]
 
           # Check if the request was cancelled before trying to process it
-          @mutex.synchronize do
+          @global_state.synchronize do
             if id && @cancelled_requests.include?(id)
-              send_message(Error.new(
-                id: id,
-                code: Constant::ErrorCodes::REQUEST_CANCELLED,
-                message: "Request #{id} was cancelled",
-              ))
+              send_message(Result.new(id: id, response: nil))
               @cancelled_requests.delete(id)
               next
             end