ruby-lsp 0.10.1 → 0.11.0

data/lib/ruby_lsp/event_emitter.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  # EventEmitter is an intermediary between our requests and Syntax Tree visitors. It's used to visit the document's AST
+  # EventEmitter is an intermediary between our requests and YARP visitors. It's used to visit the document's AST
   # and emit events that the requests can listen to for providing functionality. Usages:
   #
   # - For positional requests, locate the target node and use `emit_for_target` to fire events for each listener
@@ -18,9 +18,8 @@ module RubyLsp
   # emitter.emit_for_target(target_node)
   # listener.response
   # ```
-  class EventEmitter < SyntaxTree::Visitor
+  class EventEmitter < YARP::Visitor
     extend T::Sig
-    include SyntaxTree::WithScope
 
     sig { void }
     def initialize
@@ -35,154 +34,317 @@ module RubyLsp
 
     # Emit events for a specific node. This is similar to the regular `visit` method, but avoids going deeper into the
     # tree for performance
-    sig { params(node: T.nilable(SyntaxTree::Node)).void }
+    sig { params(node: T.nilable(YARP::Node)).void }
     def emit_for_target(node)
       case node
-      when SyntaxTree::Command
-        @listeners[:on_command]&.each { |l| T.unsafe(l).on_command(node) }
-      when SyntaxTree::CallNode
+      when YARP::CallNode
         @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
-      when SyntaxTree::TStringContent
-        @listeners[:on_tstring_content]&.each { |l| T.unsafe(l).on_tstring_content(node) }
-      when SyntaxTree::ConstPathRef
-        @listeners[:on_const_path_ref]&.each { |l| T.unsafe(l).on_const_path_ref(node) }
-      when SyntaxTree::Const
-        @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(node) }
-      when SyntaxTree::TopConstRef
-        @listeners[:on_top_const_ref]&.each { |l| T.unsafe(l).on_top_const_ref(node) }
+      when YARP::ConstantPathNode
+        @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
+      when YARP::StringNode
+        @listeners[:on_string]&.each { |l| T.unsafe(l).on_string(node) }
+      when YARP::ClassNode
+        @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }
+      when YARP::ModuleNode
+        @listeners[:on_module]&.each { |l| T.unsafe(l).on_module(node) }
+      when YARP::ConstantWriteNode
+        @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
+      when YARP::ConstantReadNode
+        @listeners[:on_constant_read]&.each { |l| T.unsafe(l).on_constant_read(node) }
       end
     end
 
     # Visit dispatchers are below. Notice that for nodes that create a new scope (e.g.: classes, modules, method defs)
     # we need both an `on_*` and `after_*` event. This is because some requests must know when we exit the scope
-    sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+    sig { override.params(node: T.nilable(YARP::Node)).void }
     def visit(node)
       @listeners[:on_node]&.each { |l| T.unsafe(l).on_node(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::ClassDeclaration).void }
-    def visit_class(node)
+    sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
+    def visit_all(nodes)
+      nodes.each { |node| visit(node) }
+    end
+
+    sig { override.params(node: YARP::ClassNode).void }
+    def visit_class_node(node)
       @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }
       super
       @listeners[:after_class]&.each { |l| T.unsafe(l).after_class(node) }
     end
 
-    sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
-    def visit_module(node)
+    sig { override.params(node: YARP::ModuleNode).void }
+    def visit_module_node(node)
       @listeners[:on_module]&.each { |l| T.unsafe(l).on_module(node) }
       super
       @listeners[:after_module]&.each { |l| T.unsafe(l).after_module(node) }
     end
 
-    sig { override.params(node: SyntaxTree::Command).void }
-    def visit_command(node)
-      @listeners[:on_command]&.each { |l| T.unsafe(l).on_command(node) }
+    sig { override.params(node: YARP::CallNode).void }
+    def visit_call_node(node)
+      @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
       super
-      @listeners[:after_command]&.each { |l| T.unsafe(l).after_command(node) }
+      @listeners[:after_call]&.each { |l| T.unsafe(l).after_call(node) }
     end
 
-    sig { override.params(node: SyntaxTree::CommandCall).void }
-    def visit_command_call(node)
-      @listeners[:on_command_call]&.each { |l| T.unsafe(l).on_command_call(node) }
+    sig { override.params(node: YARP::InstanceVariableWriteNode).void }
+    def visit_instance_variable_write_node(node)
+      @listeners[:on_instance_variable_write]&.each { |l| T.unsafe(l).on_instance_variable_write(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::CallNode).void }
-    def visit_call(node)
-      @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
+    sig { override.params(node: YARP::ClassVariableWriteNode).void }
+    def visit_class_variable_write_node(node)
+      @listeners[:on_class_variable_write]&.each { |l| T.unsafe(l).on_class_variable_write(node) }
       super
-      @listeners[:after_call]&.each { |l| T.unsafe(l).after_call(node) }
     end
 
-    sig { override.params(node: SyntaxTree::VCall).void }
-    def visit_vcall(node)
-      @listeners[:on_vcall]&.each { |l| T.unsafe(l).on_vcall(node) }
+    sig { override.params(node: YARP::DefNode).void }
+    def visit_def_node(node)
+      @listeners[:on_def]&.each { |l| T.unsafe(l).on_def(node) }
       super
+      @listeners[:after_def]&.each { |l| T.unsafe(l).after_def(node) }
     end
 
-    sig { override.params(node: SyntaxTree::ConstPathField).void }
-    def visit_const_path_field(node)
-      @listeners[:on_const_path_field]&.each { |l| T.unsafe(l).on_const_path_field(node) }
+    sig { override.params(node: YARP::BlockNode).void }
+    def visit_block_node(node)
+      @listeners[:on_block]&.each { |l| T.unsafe(l).on_block(node) }
       super
+      @listeners[:after_block]&.each { |l| T.unsafe(l).after_block(node) }
     end
 
-    sig { override.params(node: SyntaxTree::TopConstField).void }
-    def visit_top_const_field(node)
-      @listeners[:on_top_const_field]&.each { |l| T.unsafe(l).on_top_const_field(node) }
+    sig { override.params(node: YARP::SelfNode).void }
+    def visit_self_node(node)
+      @listeners[:on_self]&.each { |l| T.unsafe(l).on_self(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::DefNode).void }
-    def visit_def(node)
-      @listeners[:on_def]&.each { |l| T.unsafe(l).on_def(node) }
+    sig { override.params(node: YARP::RescueNode).void }
+    def visit_rescue_node(node)
+      @listeners[:on_rescue]&.each { |l| T.unsafe(l).on_rescue(node) }
       super
-      @listeners[:after_def]&.each { |l| T.unsafe(l).after_def(node) }
     end
 
-    sig { override.params(node: SyntaxTree::VarField).void }
-    def visit_var_field(node)
-      @listeners[:on_var_field]&.each { |l| T.unsafe(l).on_var_field(node) }
+    sig { override.params(node: YARP::BlockParameterNode).void }
+    def visit_block_parameter_node(node)
+      @listeners[:on_block_parameter]&.each { |l| T.unsafe(l).on_block_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Comment).void }
-    def visit_comment(node)
-      @listeners[:on_comment]&.each { |l| T.unsafe(l).on_comment(node) }
+    sig { override.params(node: YARP::KeywordParameterNode).void }
+    def visit_keyword_parameter_node(node)
+      @listeners[:on_keyword_parameter]&.each { |l| T.unsafe(l).on_keyword_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Rescue).void }
-    def visit_rescue(node)
-      @listeners[:on_rescue]&.each { |l| T.unsafe(l).on_rescue(node) }
+    sig { override.params(node: YARP::KeywordRestParameterNode).void }
+    def visit_keyword_rest_parameter_node(node)
+      @listeners[:on_keyword_rest_parameter]&.each { |l| T.unsafe(l).on_keyword_rest_parameter(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::OptionalParameterNode).void }
+    def visit_optional_parameter_node(node)
+      @listeners[:on_optional_parameter]&.each { |l| T.unsafe(l).on_optional_parameter(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::RequiredParameterNode).void }
+    def visit_required_parameter_node(node)
+      @listeners[:on_required_parameter]&.each { |l| T.unsafe(l).on_required_parameter(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::RestParameterNode).void }
+    def visit_rest_parameter_node(node)
+      @listeners[:on_rest_parameter]&.each { |l| T.unsafe(l).on_rest_parameter(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantReadNode).void }
+    def visit_constant_read_node(node)
+      @listeners[:on_constant_read]&.each { |l| T.unsafe(l).on_constant_read(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantPathNode).void }
+    def visit_constant_path_node(node)
+      @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantPathWriteNode).void }
+    def visit_constant_path_write_node(node)
+      @listeners[:on_constant_path_write]&.each { |l| T.unsafe(l).on_constant_path_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantWriteNode).void }
+    def visit_constant_write_node(node)
+      @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantAndWriteNode).void }
+    def visit_constant_and_write_node(node)
+      @listeners[:on_constant_and_write]&.each { |l| T.unsafe(l).on_constant_and_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantOperatorWriteNode).void }
+    def visit_constant_operator_write_node(node)
+      @listeners[:on_constant_operator_write]&.each { |l| T.unsafe(l).on_constant_operator_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantOrWriteNode).void }
+    def visit_constant_or_write_node(node)
+      @listeners[:on_constant_or_write]&.each { |l| T.unsafe(l).on_constant_or_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantTargetNode).void }
+    def visit_constant_target_node(node)
+      @listeners[:on_constant_target]&.each { |l| T.unsafe(l).on_constant_target(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableWriteNode).void }
+    def visit_local_variable_write_node(node)
+      @listeners[:on_local_variable_write]&.each { |l| T.unsafe(l).on_local_variable_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableReadNode).void }
+    def visit_local_variable_read_node(node)
+      @listeners[:on_local_variable_read]&.each { |l| T.unsafe(l).on_local_variable_read(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableAndWriteNode).void }
+    def visit_local_variable_and_write_node(node)
+      @listeners[:on_local_variable_and_write]&.each { |l| T.unsafe(l).on_local_variable_and_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableOperatorWriteNode).void }
+    def visit_local_variable_operator_write_node(node)
+      @listeners[:on_local_variable_operator_write]&.each { |l| T.unsafe(l).on_local_variable_operator_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableOrWriteNode).void }
+    def visit_local_variable_or_write_node(node)
+      @listeners[:on_local_variable_or_write]&.each { |l| T.unsafe(l).on_local_variable_or_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableTargetNode).void }
+    def visit_local_variable_target_node(node)
+      @listeners[:on_local_variable_target]&.each { |l| T.unsafe(l).on_local_variable_target(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::BlockLocalVariableNode).void }
+    def visit_block_local_variable_node(node)
+      @listeners[:on_block_local_variable]&.each { |l| T.unsafe(l).on_block_local_variable(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::IfNode).void }
+    def visit_if_node(node)
+      @listeners[:on_if]&.each { |l| T.unsafe(l).on_if(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::InNode).void }
+    def visit_in_node(node)
+      @listeners[:on_in]&.each { |l| T.unsafe(l).on_in(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::WhenNode).void }
+    def visit_when_node(node)
+      @listeners[:on_when]&.each { |l| T.unsafe(l).on_when(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::InterpolatedStringNode).void }
+    def visit_interpolated_string_node(node)
+      @listeners[:on_interpolated_string]&.each { |l| T.unsafe(l).on_interpolated_string(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ArrayNode).void }
+    def visit_array_node(node)
+      @listeners[:on_array]&.each { |l| T.unsafe(l).on_array(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::CaseNode).void }
+    def visit_case_node(node)
+      @listeners[:on_case]&.each { |l| T.unsafe(l).on_case(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ForNode).void }
+    def visit_for_node(node)
+      @listeners[:on_for]&.each { |l| T.unsafe(l).on_for(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::HashNode).void }
+    def visit_hash_node(node)
+      @listeners[:on_hash]&.each { |l| T.unsafe(l).on_hash(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Kw).void }
-    def visit_kw(node)
-      @listeners[:on_kw]&.each { |l| T.unsafe(l).on_kw(node) }
+    sig { override.params(node: YARP::SingletonClassNode).void }
+    def visit_singleton_class_node(node)
+      @listeners[:on_singleton_class]&.each { |l| T.unsafe(l).on_singleton_class(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Params).void }
-    def visit_params(node)
-      @listeners[:on_params]&.each { |l| T.unsafe(l).on_params(node) }
+    sig { override.params(node: YARP::UnlessNode).void }
+    def visit_unless_node(node)
+      @listeners[:on_unless]&.each { |l| T.unsafe(l).on_unless(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Field).void }
-    def visit_field(node)
-      @listeners[:on_field]&.each { |l| T.unsafe(l).on_field(node) }
+    sig { override.params(node: YARP::UntilNode).void }
+    def visit_until_node(node)
+      @listeners[:on_until]&.each { |l| T.unsafe(l).on_until(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::VarRef).void }
-    def visit_var_ref(node)
-      @listeners[:on_var_ref]&.each { |l| T.unsafe(l).on_var_ref(node) }
+    sig { override.params(node: YARP::WhileNode).void }
+    def visit_while_node(node)
+      @listeners[:on_while]&.each { |l| T.unsafe(l).on_while(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::BlockVar).void }
-    def visit_block_var(node)
-      @listeners[:on_block_var]&.each { |l| T.unsafe(l).on_block_var(node) }
+    sig { override.params(node: YARP::ElseNode).void }
+    def visit_else_node(node)
+      @listeners[:on_else]&.each { |l| T.unsafe(l).on_else(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::LambdaVar).void }
-    def visit_lambda_var(node)
-      @listeners[:on_lambda_var]&.each { |l| T.unsafe(l).on_lambda_var(node) }
+    sig { override.params(node: YARP::EnsureNode).void }
+    def visit_ensure_node(node)
+      @listeners[:on_ensure]&.each { |l| T.unsafe(l).on_ensure(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Binary).void }
-    def visit_binary(node)
+    sig { override.params(node: YARP::BeginNode).void }
+    def visit_begin_node(node)
+      @listeners[:on_begin]&.each { |l| T.unsafe(l).on_begin(node) }
       super
-      @listeners[:after_binary]&.each { |l| T.unsafe(l).after_binary(node) }
     end
 
-    sig { override.params(node: SyntaxTree::Const).void }
-    def visit_const(node)
-      @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(node) }
+    sig { override.params(node: YARP::StringConcatNode).void }
+    def visit_string_concat_node(node)
+      @listeners[:on_string_concat]&.each { |l| T.unsafe(l).on_string_concat(node) }
       super
     end
   end

data/lib/ruby_lsp/executor.rb

@@ -13,7 +13,6 @@ module RubyLsp
       # Requests that mutate the store must be run sequentially! Parallel requests only receive a temporary copy of the
       # store
       @store = store
-      @test_library = T.let(DependencyDetector.detected_test_library, String)
       @message_queue = message_queue
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
     end
@@ -23,13 +22,13 @@ module RubyLsp
       response = T.let(nil, T.untyped)
       error = T.let(nil, T.nilable(Exception))
 
-      request_time = Benchmark.realtime do
+      begin
         response = run(request)
       rescue StandardError, LoadError => e
         error = e
       end
 
-      Result.new(response: response, error: error, request_time: request_time)
+      Result.new(response: response, error: error)
     end
 
     private
@@ -42,20 +41,20 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
-        Extension.load_extensions
+        Addon.load_addons
 
-        errored_extensions = Extension.extensions.select(&:error?)
+        errored_addons = Addon.addons.select(&:error?)
 
-        if errored_extensions.any?
+        if errored_addons.any?
           @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::WARNING,
-              message: "Error loading extensions:\n\n#{errored_extensions.map(&:formatted_errors).join("\n\n")}",
+              message: "Error loading addons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
             ),
           )
 
-          warn(errored_extensions.map(&:backtraces).join("\n\n"))
+          warn(errored_addons.map(&:backtraces).join("\n\n"))
         end
 
         perform_initial_indexing
@@ -82,12 +81,10 @@ module RubyLsp
           request.dig(:params, :contentChanges),
           request.dig(:params, :textDocument, :version),
         )
-      when "textDocument/foldingRange"
-        folding_range(uri)
       when "textDocument/selectionRange"
         selection_range(uri, request.dig(:params, :positions))
       when "textDocument/documentSymbol", "textDocument/documentLink", "textDocument/codeLens",
-           "textDocument/semanticTokens/full"
+           "textDocument/semanticTokens/full", "textDocument/foldingRange"
         document = @store.get(uri)
 
         # If the response has already been cached by another request, return it
@@ -96,15 +93,17 @@ module RubyLsp
 
         # Run listeners for the document
         emitter = EventEmitter.new
+        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, emitter, @message_queue)
         document_symbol = Requests::DocumentSymbol.new(emitter, @message_queue)
-        document_link = Requests::DocumentLink.new(uri, emitter, @message_queue)
-        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue, @test_library)
+        document_link = Requests::DocumentLink.new(uri, document.comments, emitter, @message_queue)
+        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue)
 
         semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
-        emitter.visit(document.tree) if document.parsed?
+        emitter.visit(document.tree)
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
+        document.cache_set("textDocument/foldingRange", folding_range.response)
         document.cache_set("textDocument/documentSymbol", document_symbol.response)
         document.cache_set("textDocument/documentLink", document_link.response)
         document.cache_set("textDocument/codeLens", code_lens.response)
@@ -246,28 +245,25 @@ module RubyLsp
     end
     def definition(uri, position)
       document = @store.get(uri)
-      return if document.syntax_error?
-
       target, parent, nesting = document.locate_node(
         position,
-        node_types: [SyntaxTree::Command, SyntaxTree::Const, SyntaxTree::ConstPathRef],
+        node_types: [YARP::CallNode, YARP::ConstantReadNode, YARP::ConstantPathNode],
       )
 
-      target = parent if target.is_a?(SyntaxTree::Const) && parent.is_a?(SyntaxTree::ConstPathRef)
+      target = parent if target.is_a?(YARP::ConstantReadNode) && parent.is_a?(YARP::ConstantPathNode)
 
       emitter = EventEmitter.new
-      base_listener = Requests::Definition.new(uri, nesting, @index, emitter, @message_queue)
+      base_listener = Requests::Definition.new(
+        uri,
+        nesting,
+        @index,
+        emitter,
+        @message_queue,
+      )
       emitter.emit_for_target(target)
       base_listener.response
     end
 
-    sig { params(uri: URI::Generic).returns(T::Array[Interface::FoldingRange]) }
-    def folding_range(uri)
-      @store.cache_fetch(uri, "textDocument/foldingRange") do |document|
-        Requests::FoldingRanges.new(document).run
-      end
-    end
-
     sig do
       params(
         uri: URI::Generic,
@@ -276,8 +272,6 @@ module RubyLsp
     end
     def hover(uri, position)
       document = @store.get(uri)
-      return if document.syntax_error?
-
       target, parent, nesting = document.locate_node(
         position,
         node_types: Requests::Hover::ALLOWED_TARGETS,
@@ -285,7 +279,7 @@ module RubyLsp
 
       if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
           !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(SyntaxTree::ConstPathRef) && target.is_a?(SyntaxTree::Const))
+          (parent.is_a?(YARP::ConstantPathNode) && target.is_a?(YARP::ConstantReadNode))
         target = parent
       end
 
@@ -371,7 +365,6 @@ module RubyLsp
     end
     def document_highlight(uri, position)
       document = @store.get(uri)
-      return if document.syntax_error?
 
       target, parent = document.locate_node(position)
       emitter = EventEmitter.new
@@ -383,7 +376,6 @@ module RubyLsp
     sig { params(uri: URI::Generic, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
     def inlay_hint(uri, range)
       document = @store.get(uri)
-      return if document.syntax_error?
 
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
@@ -443,7 +435,7 @@ module RubyLsp
         Requests::Diagnostics.new(document).run
       end
 
-      Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
+      Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response) if response
     end
 
     sig { params(uri: URI::Generic, range: Document::RangeShape).returns(Interface::SemanticTokens) }
@@ -458,7 +450,7 @@ module RubyLsp
         @message_queue,
         range: start_line..end_line,
       )
-      emitter.visit(document.tree) if document.parsed?
+      emitter.visit(document.tree)
 
       Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
     end
@@ -471,7 +463,6 @@ module RubyLsp
     end
     def completion(uri, position)
       document = @store.get(uri)
-      return unless document.parsed?
 
       char_position = document.create_scanner.find_char_position(position)
 
@@ -480,35 +471,29 @@ module RubyLsp
       # the node, as it could not be a constant
       target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
         char_position -= 1
-        [SyntaxTree::Const, SyntaxTree::ConstPathRef, SyntaxTree::TopConstRef]
+        [YARP::ConstantReadNode, YARP::ConstantPathNode]
       else
-        [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode]
+        [YARP::CallNode]
       end
 
-      matched, parent, nesting = document.locate(T.must(document.tree), char_position, node_types: target_node_types)
+      matched, parent, nesting = document.locate(document.tree, char_position, node_types: target_node_types)
       return unless matched && parent
 
       target = case matched
-      when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
+      when YARP::CallNode
         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)
+        return unless message == "require"
 
-        argument = args.parts.first
-        return unless argument.is_a?(SyntaxTree::StringLiteral)
+        args = matched.arguments&.arguments
+        return if args.nil? || args.is_a?(YARP::ForwardingArgumentsNode)
 
-        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?(char_position)
+        argument = args.first
+        return unless argument.is_a?(YARP::StringNode)
+        return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
 
-        path_node
-      when SyntaxTree::Const, SyntaxTree::ConstPathRef
-        if (parent.is_a?(SyntaxTree::ConstPathRef) || parent.is_a?(SyntaxTree::TopConstRef)) &&
-            matched.is_a?(SyntaxTree::Const)
+        argument
+      when YARP::ConstantReadNode, YARP::ConstantPathNode
+        if parent.is_a?(YARP::ConstantPathNode) && matched.is_a?(YARP::ConstantReadNode)
           parent
         else
           matched
@@ -518,7 +503,12 @@ module RubyLsp
       return unless target
 
       emitter = EventEmitter.new
-      listener = Requests::Completion.new(@index, nesting, emitter, @message_queue)
+      listener = Requests::Completion.new(
+        @index,
+        nesting,
+        emitter,
+        @message_queue,
+      )
       emitter.emit_for_target(target)
       listener.response
     end
@@ -570,7 +560,7 @@ module RubyLsp
       @store.supports_progress = options.dig(:capabilities, :window, :workDoneProgress) || true
       formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
-        DependencyDetector.detected_formatter
+        DependencyDetector.instance.detected_formatter
       else
         formatter
       end