ruby-lsp 0.17.12 → 0.17.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34cae8b53cfb0811cb26d3b3dd4198a72585d1f15a98a7d8f656fd1676886630
-  data.tar.gz: f4868222c46c4cbad9a099fce69562838b5dda567f1666a82752f45fe3f501c5
+  metadata.gz: 17c576dbc88c8c4012eb777b15df7df630a827d7692f6bceec06b68178b25357
+  data.tar.gz: f023f22a818616b1c8c6fb1de77d0637e7bdae37b60b46e941b297aaa95729a9
 SHA512:
-  metadata.gz: db8e991497aa6e9388b2778fb9a417adbef07c6bb29165ff9a1718ab7cf1db6d2a6586453320d72adf0cffe78b846b553c3a0ba24b63807c52170f02f1b7d2e3
-  data.tar.gz: 80aac045ca6aaf7dbb9344f947a9b1419eaac4711448d997c902f0fb9da68e7c2338e0a5b1d81a30c0a2609defe1b656457d1a4a23b0ba5288162d142cf7c9e9
+  metadata.gz: e0848d63fef1677ccf276182cdea5a8304e4a1e04a7ec4936f8f083c27bc62f575fe3f0a207f75805cf3c8eb106e43d5d1afe2df366028980cb5eee6ed97c14b
+  data.tar.gz: d57869c1ee7dcec65becd9ee4fc225c91e946e697c3aab8a42d2453c1a85bcc91cd8e0a6364d810f8109c2b97102f101d24bf8986d2e4b3905b56368e260b0d3

data/VERSION

@@ -1 +1 @@
-0.17.12
+0.17.14

data/exe/ruby-lsp

@@ -81,6 +81,8 @@ require "ruby_lsp/load_sorbet"
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
+T::Utils.run_all_sig_blocks
+
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -112,20 +114,20 @@ if options[:time_index]
 end
 
 if options[:doctor]
+  index = RubyIndexer::Index.new
+
   if File.exist?(".index.yml")
     begin
       config = YAML.parse_file(".index.yml").to_ruby
     rescue => e
       abort("Error parsing config: #{e.message}")
     end
-    RubyIndexer.configuration.apply_config(config)
+    index.configuration.apply_config(config)
   end
 
-  index = RubyIndexer::Index.new
-
   puts "Globbing for indexable files"
 
-  RubyIndexer.configuration.indexables.each do |indexable|
+  index.configuration.indexables.each do |indexable|
     puts "indexing: #{indexable.full_path}"
     index.index_single(indexable)
   end

data/exe/ruby-lsp-check

@@ -44,7 +44,7 @@ puts "\n"
 puts "Verifying that indexing executes successfully. This may take a while..."
 
 index = RubyIndexer::Index.new
-indexables = RubyIndexer.configuration.indexables
+indexables = index.configuration.indexables
 
 indexables.each_with_index do |indexable, i|
   index.index_single(indexable)

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

@@ -552,7 +552,7 @@ module RubyIndexer
         comment_content = comment.location.slice.chomp
 
         # invalid encodings would raise an "invalid byte sequence" exception
-        if !comment_content.valid_encoding? || comment_content.match?(RubyIndexer.configuration.magic_comment_regex)
+        if !comment_content.valid_encoding? || comment_content.match?(@index.configuration.magic_comment_regex)
           next
         end
 

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

@@ -11,6 +11,9 @@ module RubyIndexer
     # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
     ENTRY_SIMILARITY_THRESHOLD = 0.7
 
+    sig { returns(Configuration) }
+    attr_reader :configuration
+
     sig { void }
     def initialize
       # Holds all entries in the index using the following format:
@@ -44,6 +47,8 @@ module RubyIndexer
         {},
         T::Hash[String, T::Array[T.proc.params(index: Index, base: Entry::Namespace).void]],
       )
+
+      @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
     end
 
     # Register an enhancement to the index. Enhancements must conform to the `Enhancement` interface
@@ -296,7 +301,7 @@ module RubyIndexer
         block: T.nilable(T.proc.params(progress: Integer).returns(T::Boolean)),
       ).void
     end
-    def index_all(indexable_paths: RubyIndexer.configuration.indexables, &block)
+    def index_all(indexable_paths: @configuration.indexables, &block)
       RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
       progress_step = (indexable_paths.length / 100.0).ceil

data/lib/ruby_indexer/ruby_indexer.rb

@@ -15,12 +15,4 @@ require "ruby_indexer/lib/ruby_indexer/location"
 require "ruby_indexer/lib/ruby_indexer/rbs_indexer"
 
 module RubyIndexer
-  @configuration = T.let(Configuration.new, Configuration)
-
-  class << self
-    extend T::Sig
-
-    sig { returns(Configuration) }
-    attr_reader :configuration
-  end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -108,7 +108,7 @@ module RubyIndexer
     end
 
     def test_magic_comments_regex
-      regex = RubyIndexer.configuration.magic_comment_regex
+      regex = @config.magic_comment_regex
 
       [
         "# frozen_string_literal:",

data/lib/ruby_lsp/addon.rb

@@ -49,15 +49,18 @@ module RubyLsp
         super
       end
 
-      # Discovers and loads all addons. Returns the list of activated addons
-      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[Addon]) }
+      # Discovers and loads all addons. Returns a list of errors when trying to require addons
+      sig do
+        params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[StandardError])
+      end
       def load_addons(global_state, outgoing_queue)
         # Require all addons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
-        Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
+        errors = Gem.find_files("ruby_lsp/**/addon.rb").filter_map do |addon|
           require File.expand_path(addon)
+          nil
         rescue => e
-          $stderr.puts(e.full_message)
+          e
         end
 
         # Instantiate all discovered addon classes
@@ -71,6 +74,8 @@ module RubyLsp
         rescue => e
           addon.add_error(e)
         end
+
+        errors
       end
 
       # Intended for use by tests for addons

data/lib/ruby_lsp/base_server.rb

@@ -65,7 +65,7 @@ module RubyLsp
         when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           process_message(message)
         when "shutdown"
-          $stderr.puts("Shutting down Ruby LSP...")
+          send_log_message("Shutting down Ruby LSP...")
 
           shutdown
 
@@ -76,7 +76,7 @@ module RubyLsp
         when "exit"
           @mutex.synchronize do
             status = @incoming_queue.closed? ? 0 : 1
-            $stderr.puts("Shutdown complete with status #{status}")
+            send_log_message("Shutdown complete with status #{status}")
             exit(status)
           end
         else
@@ -145,5 +145,10 @@ module RubyLsp
     def send_empty_response(id)
       send_message(Result.new(id: id, response: nil))
     end
+
+    sig { params(message: String, type: Integer).void }
+    def send_log_message(message, type: Constant::MessageType::LOG)
+      send_message(Notification.window_log_message(message, type: Constant::MessageType::LOG))
+    end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -7,25 +7,19 @@ module RubyLsp
       enums do
         Ruby = new("ruby")
         ERB = new("erb")
-      end
-    end
-
-    class SorbetLevel < T::Enum
-      enums do
-        None = new("none")
-        Ignore = new("ignore")
-        False = new("false")
-        True = new("true")
-        Strict = new("strict")
+        RBS = new("rbs")
       end
     end
 
     extend T::Sig
     extend T::Helpers
+    extend T::Generic
+
+    ParseResultType = type_member
 
     abstract!
 
-    sig { returns(Prism::ParseResult) }
+    sig { returns(ParseResultType) }
     attr_reader :parse_result
 
     sig { returns(String) }
@@ -48,10 +42,10 @@ module RubyLsp
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(parse, Prism::ParseResult)
+      @parse_result = T.let(parse, ParseResultType)
     end
 
-    sig { params(other: Document).returns(T::Boolean) }
+    sig { params(other: Document[T.untyped]).returns(T::Boolean) }
     def ==(other)
       self.class == other.class && uri == other.uri && @source == other.source
     end
@@ -64,7 +58,7 @@ module RubyLsp
       type_parameters(:T)
         .params(
           request_name: String,
-          block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
+          block: T.proc.params(document: Document[ParseResultType]).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end
     def cache_fetch(request_name, &block)
@@ -103,7 +97,7 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { abstract.returns(Prism::ParseResult) }
+    sig { abstract.returns(ParseResultType) }
     def parse; end
 
     sig { abstract.returns(T::Boolean) }
@@ -114,169 +108,6 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
-    def locate_node(position, node_types: [])
-      locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
-    end
-
-    sig do
-      params(
-        node: Prism::Node,
-        char_position: Integer,
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
-    def locate(node, char_position, node_types: [])
-      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
-      closest = node
-      parent = T.let(nil, T.nilable(Prism::Node))
-      nesting_nodes = T.let(
-        [],
-        T::Array[T.any(
-          Prism::ClassNode,
-          Prism::ModuleNode,
-          Prism::SingletonClassNode,
-          Prism::DefNode,
-          Prism::BlockNode,
-          Prism::LambdaNode,
-          Prism::ProgramNode,
-        )],
-      )
-
-      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
-      call_node = T.let(nil, T.nilable(Prism::CallNode))
-
-      until queue.empty?
-        candidate = queue.shift
-
-        # Skip nil child nodes
-        next if candidate.nil?
-
-        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
-        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
-        # sibling
-        T.unsafe(queue).unshift(*candidate.child_nodes)
-
-        # Skip if the current node doesn't cover the desired position
-        loc = candidate.location
-        next unless (loc.start_offset...loc.end_offset).cover?(char_position)
-
-        # If the node's start character is already past the position, then we should've found the closest node
-        # already
-        break if char_position < loc.start_offset
-
-        # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
-        # need to pop the stack
-        previous_level = nesting_nodes.last
-        nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
-
-        # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
-        # target when it is a constant
-        case candidate
-        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
-          Prism::LambdaNode
-          nesting_nodes << candidate
-        end
-
-        if candidate.is_a?(Prism::CallNode)
-          arg_loc = candidate.arguments&.location
-          blk_loc = candidate.block&.location
-          if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
-              (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
-            call_node = candidate
-          end
-        end
-
-        # If there are node types to filter by, and the current node is not one of those types, then skip it
-        next if node_types.any? && node_types.none? { |type| candidate.class == type }
-
-        # If the current node is narrower than or equal to the previous closest node, then it is more precise
-        closest_loc = closest.location
-        if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
-          parent = closest
-          closest = candidate
-        end
-      end
-
-      # When targeting the constant part of a class/module definition, we do not want the nesting to be duplicated. That
-      # is, when targeting Bar in the following example:
-      #
-      # ```ruby
-      #   class Foo::Bar; end
-      # ```
-      # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack, even
-      # though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
-      if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
-        last_level = nesting_nodes.last
-
-        if (last_level.is_a?(Prism::ModuleNode) || last_level.is_a?(Prism::ClassNode)) &&
-            last_level.constant_path == closest
-          nesting_nodes.pop
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting_nodes, call_node)
-    end
-
-    sig do
-      params(
-        range: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).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])
-      desired_range = (start_position...end_position)
-      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
-
-      until queue.empty?
-        candidate = queue.shift
-
-        # Skip nil child nodes
-        next if candidate.nil?
-
-        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
-        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
-        # sibling
-        T.unsafe(queue).unshift(*candidate.child_nodes)
-
-        # Skip if the current node doesn't cover the desired position
-        loc = candidate.location
-
-        if desired_range.cover?(loc.start_offset...loc.end_offset) &&
-            (node_types.empty? || node_types.any? { |type| candidate.class == type })
-          return candidate
-        end
-      end
-    end
-
-    sig { returns(SorbetLevel) }
-    def sorbet_level
-      sigil = parse_result.magic_comments.find do |comment|
-        comment.key == "typed"
-      end&.value
-
-      case sigil
-      when "ignore"
-        SorbetLevel::Ignore
-      when "false"
-        SorbetLevel::False
-      when "true"
-        SorbetLevel::True
-      when "strict", "strong"
-        SorbetLevel::Strict
-      else
-        SorbetLevel::None
-      end
-    end
-
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/erb_document.rb

@@ -4,15 +4,19 @@
 module RubyLsp
   class ERBDocument < Document
     extend T::Sig
+    extend T::Generic
 
-    sig { override.returns(Prism::ParseResult) }
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
+    sig { override.returns(ParseResultType) }
     def parse
       return @parse_result unless @needs_parsing
 
       @needs_parsing = false
       scanner = ERBScanner.new(@source)
       scanner.scan
-      @parse_result = Prism.parse(scanner.ruby)
+      # assigning empty scopes to turn Prism into eval mode
+      @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
     end
 
     sig { override.returns(T::Boolean) }
@@ -25,6 +29,16 @@ module RubyLsp
       LanguageId::ERB
     end
 
+    sig do
+      params(
+        position: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(NodeContext)
+    end
+    def locate_node(position, node_types: [])
+      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+    end
+
     class ERBScanner
       extend T::Sig
 

data/lib/ruby_lsp/global_state.rb

@@ -57,21 +57,48 @@ module RubyLsp
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    # Applies the options provided by the editor and returns an array of notifications to send back to the client
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
     def apply_options(options)
+      notifications = []
       direct_dependencies = gather_direct_dependencies
       all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
-      @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
+
+      if specified_formatter
+        @formatter = specified_formatter
+
+        if specified_formatter != "auto"
+          notifications << Notification.window_log_message("Using formatter specified by user: #{@formatter}")
+        end
+      end
+
+      if @formatter == "auto"
+        @formatter = detect_formatter(direct_dependencies, all_dependencies)
+        notifications << Notification.window_log_message("Auto detected formatter: #{@formatter}")
+      end
 
       specified_linters = options.dig(:initializationOptions, :linters)
       @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
+
+      notifications << if specified_linters
+        Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
+      else
+        Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
+      end
+
       @test_library = detect_test_library(direct_dependencies)
-      @has_type_checker = detect_typechecker(direct_dependencies)
+      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
+
+      @has_type_checker = detect_typechecker(all_dependencies)
+      if @has_type_checker
+        notifications << Notification.window_log_message(
+          "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",
+        )
+      end
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -91,6 +118,8 @@ module RubyLsp
 
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @type_inferrer.experimental_features = @experimental_features
+
+      notifications
     end
 
     sig { returns(String) }
@@ -163,16 +192,7 @@ module RubyLsp
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
-      # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
-      ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
-      Bundler.with_original_env do
-        sorbet_static_detected = dependencies.any?(/^sorbet-static/)
-        # Don't show message while running tests, since it's noisy
-        if sorbet_static_detected && !ruby_lsp_env_is_test
-          $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
-        end
-        sorbet_static_detected
-      end
+      dependencies.any?(/^sorbet-static/)
     rescue Bundler::GemfileNotFound
       false
     end

data/lib/ruby_lsp/internal.rb

@@ -36,6 +36,7 @@ require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
 require "ruby_lsp/erb_document"
+require "ruby_lsp/rbs_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listeners/completion.rb

@@ -56,7 +56,7 @@ module RubyLsp
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           global_state: GlobalState,
           node_context: NodeContext,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
           trigger_character: T.nilable(String),
@@ -99,7 +99,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -122,7 +122,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -134,7 +134,7 @@ module RubyLsp
       def on_call_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        if @sorbet_level == Document::SorbetLevel::Ignore
+        if @sorbet_level == RubyDocument::SorbetLevel::Ignore
           receiver = node.receiver
 
           # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke
@@ -257,7 +257,7 @@ module RubyLsp
       def handle_instance_variable_completion(name, location)
         # 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 == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type

data/lib/ruby_lsp/listeners/definition.rb

@@ -20,7 +20,7 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
@@ -181,7 +181,7 @@ module RubyLsp
       def handle_instance_variable_definition(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 == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -289,7 +289,7 @@ module RubyLsp
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
           file_path = entry.file_path
-          next if @sorbet_level != Document::SorbetLevel::Ignore && not_in_dependencies?(file_path)
+          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(file_path)
 
           @response_builder << Interface::LocationLink.new(
             target_uri: URI::Generic.from_path(path: file_path).to_s,

data/lib/ruby_lsp/listeners/hover.rb

@@ -42,7 +42,7 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
@@ -73,7 +73,7 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -83,14 +83,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        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 @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -193,7 +193,7 @@ module RubyLsp
       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 == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -13,7 +13,7 @@ module RubyLsp
           global_state: GlobalState,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)