ruby-lsp 0.17.4 → 0.17.13

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::SuperNode,
+          Prism::ForwardingSuperNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -40,17 +42,17 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
         @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
 
         dispatcher.register(
           self,
@@ -64,12 +66,14 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @typechecker_enabled
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -79,14 +83,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @global_state.has_type_checker
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.has_type_checker
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -101,22 +105,12 @@ module RubyLsp
           return
         end
 
-        return if @typechecker_enabled
+        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
 
         message = node.message
         return unless message
 
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        methods = @index.resolve_method(message, type)
-        return unless methods
-
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
-
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
-          @response_builder.push(content, category: category)
-        end
+        handle_method_hover(message)
       end
 
       sig { params(node: Prism::InstanceVariableReadNode).void }
@@ -149,14 +143,62 @@ module RubyLsp
         handle_instance_variable_hover(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_hover
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_hover
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_hover
+        # Sorbet can handle super hover on typed true or higher
+        return if sorbet_level_true_or_higher?(@sorbet_level)
+
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_hover(surrounding_method, inherited_only: true)
+      end
+
+      sig { params(message: String, inherited_only: T::Boolean).void }
+      def handle_method_hover(message, inherited_only: false)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
+        return unless methods
+
+        first_method = T.must(methods.first)
+
+        title = "#{message}#{first_method.decorated_parameters}"
+        title << first_method.formatted_signatures
+
+        if type.is_a?(TypeInferrer::GuessedType)
+          title << "\n\nGuessed receiver: #{type.name}"
+          @response_builder.push("[Learn more about guessed types](#{GUESSED_TYPES_URL})\n", category: :links)
+        end
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type)
+        entries = @index.resolve_instance_variable(name, type.name)
         return unless entries
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -13,11 +13,11 @@ module RubyLsp
           global_state: GlobalState,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, node_context, dispatcher, typechecker_enabled)
-        @typechecker_enabled = typechecker_enabled
+      def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)
+        @sorbet_level = sorbet_level
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
@@ -28,7 +28,7 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return if @typechecker_enabled
+        return if sorbet_level_true_or_higher?(@sorbet_level)
 
         message = node.message
         return unless message
@@ -36,7 +36,7 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type)
+        methods = @index.resolve_method(message, type.name)
         return unless methods
 
         target_method = methods.first
@@ -61,6 +61,13 @@ module RubyLsp
           active_parameter += 1
         end
 
+        title = +""
+
+        extra_links = if type.is_a?(TypeInferrer::GuessedType)
+          title << "\n\nGuessed receiver: #{type.name}"
+          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
+        end
+
         signature_help = Interface::SignatureHelp.new(
           signatures: [
             Interface::SignatureInformation.new(
@@ -68,7 +75,7 @@ module RubyLsp
               parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
               documentation: Interface::MarkupContent.new(
                 kind: "markdown",
-                value: markdown_from_index_entries("", methods),
+                value: markdown_from_index_entries(title, methods, extra_links: extra_links),
               ),
             ),
           ],

data/lib/ruby_lsp/node_context.rb

@@ -23,22 +23,82 @@ module RubyLsp
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
-        nesting: T::Array[String],
+        nesting_nodes: T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
         call_node: T.nilable(Prism::CallNode),
-        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node, surrounding_method)
+    def initialize(node, parent, nesting_nodes, call_node)
       @node = node
       @parent = parent
-      @nesting = nesting
+      @nesting_nodes = nesting_nodes
       @call_node = call_node
-      @surrounding_method = surrounding_method
+
+      nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
+      @nesting = T.let(nesting, T::Array[String])
+      @surrounding_method = T.let(surrounding_method, T.nilable(String))
     end
 
     sig { returns(String) }
     def fully_qualified_name
       @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
     end
+
+    sig { returns(T::Array[Symbol]) }
+    def locals_for_scope
+      locals = []
+
+      @nesting_nodes.each do |node|
+        if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) || node.is_a?(Prism::SingletonClassNode) ||
+            node.is_a?(Prism::DefNode)
+          locals.clear
+        end
+
+        locals.concat(node.locals)
+      end
+
+      locals
+    end
+
+    private
+
+    sig do
+      params(nodes: T::Array[T.any(
+        Prism::ClassNode,
+        Prism::ModuleNode,
+        Prism::SingletonClassNode,
+        Prism::DefNode,
+        Prism::BlockNode,
+        Prism::LambdaNode,
+        Prism::ProgramNode,
+      )]).returns([T::Array[String], T.nilable(String)])
+    end
+    def handle_nesting_nodes(nodes)
+      nesting = []
+      surrounding_method = T.let(nil, T.nilable(String))
+
+      @nesting_nodes.each do |node|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting << node.constant_path.slice
+        when Prism::SingletonClassNode
+          nesting << "<Class:#{nesting.flat_map { |n| n.split("::") }.last}>"
+        when Prism::DefNode
+          surrounding_method = node.name.to_s
+          next unless node.receiver.is_a?(Prism::SelfNode)
+
+          nesting << "<Class:#{nesting.flat_map { |n| n.split("::") }.last}>"
+        end
+      end
+
+      [nesting, surrounding_method]
+    end
   end
 end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,6 +23,8 @@ module RubyLsp
     #
     class CodeActionResolve < Request
       extend T::Sig
+      include Support::Common
+
       NEW_VARIABLE_NAME = "new_variable"
       NEW_METHOD_NAME = "new_method"
 
@@ -36,7 +38,7 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document, code_action: T::Hash[Symbol, T.untyped]).void }
+      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
       def initialize(document, code_action)
         super()
         @document = document
@@ -45,20 +47,62 @@ module RubyLsp
 
       sig { override.returns(T.any(Interface::CodeAction, Error)) }
       def perform
+        return Error::EmptySelection if @document.source.empty?
+
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
           refactor_variable
         when CodeActions::EXTRACT_TO_METHOD_TITLE
           refactor_method
+        when CodeActions::TOGGLE_BLOCK_STYLE_TITLE
+          switch_block_style
         else
           Error::UnknownCodeAction
         end
       end
 
+      private
+
       sig { returns(T.any(Interface::CodeAction, Error)) }
-      def refactor_variable
-        return Error::EmptySelection if @document.source.empty?
+      def switch_block_style
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        target = @document.locate_first_within_range(
+          @code_action.dig(:data, :range),
+          node_types: [Prism::CallNode],
+        )
+
+        return Error::InvalidTargetRange unless target.is_a?(Prism::CallNode)
+
+        node = target.block
+        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
 
+        indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
+
+        Interface::CodeAction.new(
+          title: CodeActions::TOGGLE_BLOCK_STYLE_TITLE,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: [
+                  Interface::TextEdit.new(
+                    range: range_from_location(node.location),
+                    new_text: recursively_switch_nested_block_styles(node, indentation),
+                  ),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
+
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def refactor_variable
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -69,7 +113,7 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = @document
-          .locate(@document.tree, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
+          .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
@@ -153,8 +197,6 @@ module RubyLsp
 
       sig { returns(T.any(Interface::CodeAction, Error)) }
       def refactor_method
-        return Error::EmptySelection if @document.source.empty?
-
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -164,7 +206,7 @@ module RubyLsp
         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
-        node_context = @document.locate(@document.tree, start_index, node_types: [Prism::DefNode])
+        node_context = @document.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
         closest_def = T.cast(node_context.node, Prism::DefNode)
         return Error::InvalidTargetRange if closest_def.nil?
 
@@ -206,8 +248,6 @@ module RubyLsp
         )
       end
 
-      private
-
       sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
@@ -218,6 +258,64 @@ module RubyLsp
           new_text: new_text,
         )
       end
+
+      sig { params(node: Prism::BlockNode, indentation: T.nilable(String)).returns(String) }
+      def recursively_switch_nested_block_styles(node, indentation)
+        parameters = node.parameters
+        body = node.body
+
+        # We use the indentation to differentiate between do...end and brace style blocks because only the do...end
+        # style requires the indentation to build the edit.
+        #
+        # If the block is using `do...end` style, we change it to a single line brace block. Newlines are turned into
+        # semi colons, so that the result is valid Ruby code and still a one liner. If the block is using brace style,
+        # we do the opposite and turn it into a `do...end` block, making all semi colons into newlines.
+        source = +""
+
+        if indentation
+          source << "do"
+          source << " #{parameters.slice}" if parameters
+          source << "\n#{indentation}  "
+          source << switch_block_body(body, indentation) if body
+          source << "\n#{indentation}end"
+        else
+          source << "{ "
+          source << "#{parameters.slice} " if parameters
+          source << switch_block_body(body, nil) if body
+          source << "}"
+        end
+
+        source
+      end
+
+      sig { params(body: Prism::Node, indentation: T.nilable(String)).returns(String) }
+      def switch_block_body(body, indentation)
+        # Check if there are any nested blocks inside of the current block
+        body_loc = body.location
+        nested_block = @document.locate_first_within_range(
+          {
+            start: { line: body_loc.start_line - 1, character: body_loc.start_column },
+            end: { line: body_loc.end_line - 1, character: body_loc.end_column },
+          },
+          node_types: [Prism::BlockNode],
+        )
+
+        body_content = body.slice.dup
+
+        # If there are nested blocks, then we change their style too and we have to mutate the string using the
+        # relative position in respect to the beginning of the body
+        if nested_block.is_a?(Prism::BlockNode)
+          location = nested_block.location
+          correction_start = location.start_offset - body_loc.start_offset
+          correction_end = location.end_offset - body_loc.start_offset
+          next_indentation = indentation ? "#{indentation}  " : nil
+
+          body_content[correction_start...correction_end] =
+            recursively_switch_nested_block_styles(nested_block, next_indentation)
+        end
+
+        indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,13 +21,17 @@ module RubyLsp
 
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
+      TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
 
       class << self
         extend T::Sig
 
-        sig { returns(Interface::CodeActionOptions) }
+        sig { returns(Interface::CodeActionRegistrationOptions) }
         def provider
-          Interface::CodeActionOptions.new(resolve_provider: true)
+          Interface::CodeActionRegistrationOptions.new(
+            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            resolve_provider: true,
+          )
         end
       end
 
@@ -66,6 +70,11 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
+          code_actions << Interface::CodeAction.new(
+            title: TOGGLE_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          )
         end
 
         code_actions

data/lib/ruby_lsp/requests/completion.rb

@@ -49,11 +49,11 @@ module RubyLsp
           document: Document,
           global_state: GlobalState,
           params: T::Hash[Symbol, T.untyped],
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, global_state, params, typechecker_enabled, dispatcher)
+      def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @dispatcher = dispatcher
@@ -61,7 +61,7 @@ module RubyLsp
         # back by 1, so that we find the right node
         char_position = document.create_scanner.find_char_position(params[:position]) - 1
         node_context = document.locate(
-          document.tree,
+          document.parse_result.value,
           char_position,
           node_types: [
             Prism::CallNode,
@@ -84,7 +84,7 @@ module RubyLsp
           @response_builder,
           global_state,
           node_context,
-          typechecker_enabled,
+          sorbet_level,
           dispatcher,
           document.uri,
           params.dig(:context, :triggerCharacter),

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -38,13 +38,16 @@ module RubyLsp
 
       sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        return @item if @item.dig(:data, :skip_resolve)
+
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
-        # other than label details and documentation. If we modify anything, the completion behaviour might be broken.
+        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might
+        # be broken.
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
-        label = @item[:label]
+        label = @item[:label].dup
         entries = @index[label] || []
 
         owner_name = @item.dig(:data, :owner_name)
@@ -59,18 +62,20 @@ module RubyLsp
         first_entry = T.must(entries.first)
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
-          detail = first_entry.decorated_parameters
-          label = "#{label}#{first_entry.decorated_parameters}"
+          label = +"#{label}#{first_entry.decorated_parameters}"
+          label << first_entry.formatted_signatures
         end
 
-        @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
-          description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
-          detail: detail,
-        )
+        guessed_type = @item.dig(:data, :guessed_type)
+
+        extra_links = if guessed_type
+          label << "\n\nGuessed receiver: #{guessed_type}"
+          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
+        end
 
         @item[:documentation] = Interface::MarkupContent.new(
           kind: "markdown",
-          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
+          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
         )
 
         @item

data/lib/ruby_lsp/requests/definition.rb

@@ -30,20 +30,26 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
+      SPECIAL_METHOD_CALLS = [
+        :require,
+        :require_relative,
+        :autoload,
+      ].freeze
+
       sig do
         params(
           document: Document,
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
         @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)].new,
+          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)],
         )
         @dispatcher = dispatcher
 
@@ -62,6 +68,8 @@ module RubyLsp
             Prism::InstanceVariableWriteNode,
             Prism::SymbolNode,
             Prism::StringNode,
+            Prism::SuperNode,
+            Prism::ForwardingSuperNode,
           ],
         )
 
@@ -76,8 +84,9 @@ module RubyLsp
             parent,
             position,
           )
-        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
-            !covers_position?(target.message_loc, position)
+        elsif target.is_a?(Prism::CallNode) && !SPECIAL_METHOD_CALLS.include?(target.message) && !covers_position?(
+          target.message_loc, position
+        )
           # If the target is a method call, we need to ensure that the requested position is exactly on top of the
           # method identifier. Otherwise, we risk showing definitions for unrelated things
           target = nil
@@ -90,10 +99,11 @@ module RubyLsp
           Listeners::Definition.new(
             @response_builder,
             global_state,
+            document.language_id,
             document.uri,
             node_context,
             dispatcher,
-            typechecker_enabled,
+            sorbet_level,
           )
 
           Addon.addons.each do |addon|
@@ -104,7 +114,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
       end
 
-      sig { override.returns(T::Array[Interface::Location]) }
+      sig { override.returns(T::Array[T.any(Interface::Location, Interface::LocationLink)]) }
       def perform
         @dispatcher.dispatch_once(@target) if @target
         @response_builder.response

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -22,12 +22,13 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(T::Hash[Symbol, T::Boolean]) }
+        sig { returns(Interface::DiagnosticRegistrationOptions) }
         def provider
-          {
-            interFileDependencies: false,
-            workspaceDiagnostics: false,
-          }
+          Interface::DiagnosticRegistrationOptions.new(
+            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            inter_file_dependencies: false,
+            workspace_diagnostics: false,
+          )
         end
       end