ruby-lsp 0.23.1 → 0.23.5

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,22 +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
-            status = @incoming_queue.closed? ? 0 : 1
-            send_log_message("Shutdown complete with status #{status}")
-            exit(status)
-          end
+          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
         else
           @incoming_queue << message
         end
@@ -121,8 +115,8 @@ module RubyLsp
       @outgoing_queue.close
       @cancelled_requests.clear
 
-      @worker.join
-      @outgoing_dispatcher.join
+      @worker.terminate
+      @outgoing_dispatcher.terminate
       @store.clear
     end
 
@@ -157,13 +151,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

data/lib/ruby_lsp/document.rb

@@ -40,19 +40,24 @@ module RubyLsp
     sig { returns(Encoding) }
     attr_reader :encoding
 
+    sig { returns(T.nilable(Edit)) }
+    attr_reader :last_edit
+
     sig { returns(T.any(Interface::SemanticTokens, Object)) }
     attr_accessor :semantic_tokens
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
+      @source = source
+      @version = version
+      @global_state = global_state
       @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
       @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
-      @encoding = T.let(encoding, Encoding)
-      @source = T.let(source, String)
-      @version = T.let(version, Integer)
+      @encoding = T.let(global_state.encoding, Encoding)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
       @parse_result = T.let(T.unsafe(nil), ParseResultType)
+      @last_edit = T.let(nil, T.nilable(Edit))
       parse!
     end
 
@@ -64,7 +69,6 @@ module RubyLsp
     sig { abstract.returns(LanguageId) }
     def language_id; end
 
-    # TODO: remove this method once all non-positional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
         .params(
@@ -106,6 +110,19 @@ module RubyLsp
       @version = version
       @needs_parsing = true
       @cache.clear
+
+      last_edit = edits.last
+      return unless last_edit
+
+      last_edit_range = last_edit[:range]
+
+      @last_edit = if last_edit_range[:start] == last_edit_range[:end]
+        Insert.new(last_edit_range)
+      elsif last_edit[:text].empty?
+        Delete.new(last_edit_range)
+      else
+        Replace.new(last_edit_range)
+      end
     end
 
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
@@ -115,16 +132,52 @@ module RubyLsp
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end
 
+    sig { returns(T::Boolean) }
+    def past_expensive_limit?
+      @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
+    end
+
+    sig do
+      params(
+        start_pos: T::Hash[Symbol, T.untyped],
+        end_pos: T.nilable(T::Hash[Symbol, T.untyped]),
+      ).returns([Integer, T.nilable(Integer)])
+    end
+    def find_index_by_position(start_pos, end_pos = nil)
+      @global_state.synchronize do
+        scanner = create_scanner
+        start_index = scanner.find_char_position(start_pos)
+        end_index = scanner.find_char_position(end_pos) if end_pos
+        [start_index, end_index]
+      end
+    end
+
+    private
+
     sig { returns(Scanner) }
     def create_scanner
       Scanner.new(@source, @encoding)
     end
 
-    sig { returns(T::Boolean) }
-    def past_expensive_limit?
-      @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
+    class Edit
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :range
+
+      sig { params(range: T::Hash[Symbol, T.untyped]).void }
+      def initialize(range)
+        @range = range
+      end
     end
 
+    class Insert < Edit; end
+    class Replace < Edit; end
+    class Delete < Edit; end
+
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/erb_document.rb

@@ -19,8 +19,8 @@ module RubyLsp
     end
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
@@ -63,9 +63,11 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
+      char_position, _ = find_index_by_position(position)
+
       RubyDocument.locate(
         @parse_result.value,
-        create_scanner.find_char_position(position),
+        char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )

data/lib/ruby_lsp/global_state.rb

@@ -29,6 +29,9 @@ module RubyLsp
     sig { returns(ClientCapabilities) }
     attr_reader :client_capabilities
 
+    sig { returns(URI::Generic) }
+    attr_reader :workspace_uri
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -53,6 +56,12 @@ module RubyLsp
       )
       @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
       @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
+      @mutex = T.let(Mutex.new, Mutex)
+    end
+
+    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }

data/lib/ruby_lsp/listeners/definition.rb

@@ -330,7 +330,8 @@ module RubyLsp
 
         methods.each do |target_method|
           uri = target_method.uri
-          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(T.must(uri.full_path))
+          full_path = uri.full_path
+          next if sorbet_level_true_or_higher?(@sorbet_level) && (!full_path || not_in_dependencies?(full_path))
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,
@@ -403,7 +404,11 @@ module RubyLsp
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
           uri = entry.uri
-          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(T.must(uri.full_path))
+          full_path = uri.full_path
+
+          if @sorbet_level != RubyDocument::SorbetLevel::Ignore && (!full_path || not_in_dependencies?(full_path))
+            next
+          end
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,

data/lib/ruby_lsp/rbs_document.rb

@@ -8,8 +8,8 @@ module RubyLsp
 
     ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       @syntax_error = T.let(false, T::Boolean)
       super
     end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -92,9 +92,7 @@ module RubyLsp
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
-        scanner = @document.create_scanner
-        start_index = scanner.find_char_position(source_range[:start])
-        end_index = scanner.find_char_position(source_range[:end])
+        start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
@@ -192,9 +190,7 @@ module RubyLsp
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
-        scanner = @document.create_scanner
-        start_index = scanner.find_char_position(source_range[:start])
-        end_index = scanner.find_char_position(source_range[:end])
+        start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position

data/lib/ruby_lsp/requests/completion.rb

@@ -40,7 +40,8 @@ module RubyLsp
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
-        char_position = document.create_scanner.find_char_position(params[:position]) - 1
+        char_position, _ = document.find_index_by_position(params[:position])
+        char_position -= 1
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/definition.rb

@@ -29,7 +29,7 @@ module RubyLsp
         )
         @dispatcher = dispatcher
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -25,7 +25,7 @@ module RubyLsp
       end
       def initialize(global_state, document, position, dispatcher)
         super()
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/hover.rb

@@ -34,7 +34,7 @@ module RubyLsp
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -24,7 +24,7 @@ module RubyLsp
 
       sig { override.returns(T.nilable(Interface::Range)) }
       def perform
-        char_position = @document.create_scanner.find_char_position(@position)
+        char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,

data/lib/ruby_lsp/requests/references.rb

@@ -30,7 +30,7 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
         position = @params[:position]
-        char_position = @document.create_scanner.find_char_position(position)
+        char_position, _ = @document.find_index_by_position(position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,

data/lib/ruby_lsp/requests/rename.rb

@@ -40,7 +40,7 @@ module RubyLsp
 
       sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
       def perform
-        char_position = @document.create_scanner.find_char_position(@position)
+        char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,
@@ -116,8 +116,8 @@ module RubyLsp
         T.must(@global_state.index[fully_qualified_name]).each do |entry|
           # Do not rename files that are not part of the workspace
           uri = entry.uri
-          file_path = T.must(uri.full_path)
-          next unless file_path.start_with?(@global_state.workspace_path)
+          file_path = uri.full_path
+          next unless file_path&.start_with?(@global_state.workspace_path)
 
           case entry
           when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -31,10 +31,7 @@ module RubyLsp
       sig { returns(String) }
       def ast_for_range
         range = T.must(@range)
-
-        scanner = @document.create_scanner
-        start_char = scanner.find_char_position(range[:start])
-        end_char = scanner.find_char_position(range[:end])
+        start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
         found_nodes = []

data/lib/ruby_lsp/requests/signature_help.rb

@@ -36,7 +36,7 @@ module RubyLsp
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

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

@@ -31,7 +31,7 @@ module RubyLsp
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: RubyDocument, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        sig { params(document: RubyDocument, offense: ::RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(document, offense, uri)
           @document = document
           @offense = offense
@@ -48,7 +48,7 @@ module RubyLsp
           code_actions
         end
 
-        sig { params(config: RuboCop::Config).returns(Interface::Diagnostic) }
+        sig { params(config: ::RuboCop::Config).returns(Interface::Diagnostic) }
         def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
@@ -90,7 +90,7 @@ module RubyLsp
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { params(config: RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        sig { params(config: ::RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
         def code_description(config)
           cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
           return unless cop

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

@@ -40,10 +40,10 @@ module RubyLsp
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: T.any(RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
+        sig { params(rubocop_error: T.any(::RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
         def initialize(rubocop_error)
           message = case rubocop_error
-          when RuboCop::ErrorWithAnalyzedFileLocation
+          when ::RuboCop::ErrorWithAnalyzedFileLocation
             format(MESSAGE, "for the #{rubocop_error.cop.name} cop")
           when StandardError
             format(MESSAGE, rubocop_error.message)
@@ -53,7 +53,7 @@ module RubyLsp
       end
 
       # :nodoc:
-      class RuboCopRunner < RuboCop::Runner
+      class RuboCopRunner < ::RuboCop::Runner
         extend T::Sig
 
         class ConfigurationError < StandardError; end
@@ -68,14 +68,14 @@ module RubyLsp
           T::Array[String],
         )
 
-        sig { returns(T::Array[RuboCop::Cop::Offense]) }
+        sig { returns(T::Array[::RuboCop::Cop::Offense]) }
         attr_reader :offenses
 
         sig { returns(::RuboCop::Config) }
         attr_reader :config_for_working_directory
 
         begin
-          RuboCop::Options.new.parse(["--raise-cop-error"])
+          ::RuboCop::Options.new.parse(["--raise-cop-error"])
           DEFAULT_ARGS << "--raise-cop-error"
         rescue OptionParser::InvalidOption
           # older versions of RuboCop don't support this flag
@@ -85,7 +85,7 @@ module RubyLsp
         sig { params(args: String).void }
         def initialize(*args)
           @options = T.let({}, T::Hash[Symbol, T.untyped])
-          @offenses = T.let([], T::Array[RuboCop::Cop::Offense])
+          @offenses = T.let([], T::Array[::RuboCop::Cop::Offense])
           @errors = T.let([], T::Array[String])
           @warnings = T.let([], T::Array[String])
 
@@ -113,9 +113,9 @@ module RubyLsp
           # RuboCop rescues interrupts and then sets the `@aborting` variable to true. We don't want them to be rescued,
           # so here we re-raise in case RuboCop received an interrupt.
           raise Interrupt if aborting?
-        rescue RuboCop::Runner::InfiniteCorrectionLoop => error
+        rescue ::RuboCop::Runner::InfiniteCorrectionLoop => error
           raise Formatting::Error, error.message
-        rescue RuboCop::ValidationError => error
+        rescue ::RuboCop::ValidationError => error
           raise ConfigurationError, error.message
         rescue StandardError => error
           raise InternalRuboCopError, error
@@ -129,25 +129,25 @@ module RubyLsp
         class << self
           extend T::Sig
 
-          sig { params(cop_name: String).returns(T.nilable(T.class_of(RuboCop::Cop::Base))) }
+          sig { params(cop_name: String).returns(T.nilable(T.class_of(::RuboCop::Cop::Base))) }
           def find_cop_by_name(cop_name)
             cop_registry[cop_name]&.first
           end
 
           private
 
-          sig { returns(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]) }
+          sig { returns(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]) }
           def cop_registry
             @cop_registry ||= T.let(
-              RuboCop::Cop::Registry.global.to_h,
-              T.nilable(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]),
+              ::RuboCop::Cop::Registry.global.to_h,
+              T.nilable(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]),
             )
           end
         end
 
         private
 
-        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        sig { params(_file: String, offenses: T::Array[::RuboCop::Cop::Offense]).void }
         def file_finished(_file, offenses)
           @offenses = offenses
         end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -22,10 +22,10 @@ module RubyLsp
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
           uri = entry.uri
-          file_path = T.must(uri.full_path)
+          file_path = uri.full_path
 
           # We only show symbols declared in the workspace
-          in_dependencies = !not_in_dependencies?(file_path)
+          in_dependencies = file_path && !not_in_dependencies?(file_path)
           next if in_dependencies
 
           # We should never show private symbols when searching the entire workspace

data/lib/ruby_lsp/ruby_document.rb

@@ -8,6 +8,22 @@ module RubyLsp
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
+    METHODS_THAT_CHANGE_DECLARATIONS = [
+      :private_constant,
+      :attr_reader,
+      :attr_writer,
+      :attr_accessor,
+      :alias_method,
+      :include,
+      :prepend,
+      :extend,
+      :public,
+      :protected,
+      :private,
+      :module_function,
+      :private_class_method,
+    ].freeze
+
     class SorbetLevel < T::Enum
       enums do
         None = new("none")
@@ -142,8 +158,8 @@ module RubyLsp
     end
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       super
       @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
         T.proc.params(arg0: Integer).returns(Integer),
@@ -198,9 +214,8 @@ module RubyLsp
       ).returns(T.nilable(Prism::Node))
     end
     def locate_first_within_range(range, node_types: [])
-      scanner = create_scanner
-      start_position = scanner.find_char_position(range[:start])
-      end_position = scanner.find_char_position(range[:end])
+      start_position, end_position = find_index_by_position(range[:start], range[:end])
+
       desired_range = (start_position...end_position)
       queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
 
@@ -232,12 +247,66 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
+      char_position, _ = find_index_by_position(position)
+
       RubyDocument.locate(
         @parse_result.value,
-        create_scanner.find_char_position(position),
+        char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )
     end
+
+    sig { returns(T::Boolean) }
+    def last_edit_may_change_declarations?
+      # This method controls when we should index documents. If there's no recent edit and the document has just been
+      # opened, we need to index it
+      return true unless @last_edit
+
+      case @last_edit
+      when Delete
+        # Not optimized yet. It's not trivial to identify that a declaration has been removed since the source is no
+        # longer there and we don't remember the deleted text
+        true
+      when Insert, Replace
+        position_may_impact_declarations?(@last_edit.range[:start])
+      else
+        false
+      end
+    end
+
+    private
+
+    sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
+    def position_may_impact_declarations?(position)
+      node_context = locate_node(position)
+      node_at_edit = node_context.node
+
+      # Adjust to the parent when editing the constant of a class/module declaration
+      if node_at_edit.is_a?(Prism::ConstantReadNode) || node_at_edit.is_a?(Prism::ConstantPathNode)
+        node_at_edit = node_context.parent
+      end
+
+      case node_at_edit
+      when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode,
+          Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
+          Prism::ConstantPathAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantWriteNode,
+          Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode,
+          Prism::GlobalVariableWriteNode, Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableTargetNode, Prism::AliasMethodNode
+        true
+      when Prism::MultiWriteNode
+        [*node_at_edit.lefts, *node_at_edit.rest, *node_at_edit.rights].any? do |node|
+          node.is_a?(Prism::ConstantTargetNode) || node.is_a?(Prism::ConstantPathTargetNode)
+        end
+      when Prism::CallNode
+        receiver = node_at_edit.receiver
+        (!receiver || receiver.is_a?(Prism::SelfNode)) && METHODS_THAT_CHANGE_DECLARATIONS.include?(node_at_edit.name)
+      else
+        false
+      end
+    end
   end
 end