Refactor @typechecker_enabled checks

This commit also refactors all `DependencyDetector.instance.typechecker` calls to use the argument passed in on initialize

lib/ruby_lsp/document.rb

@@ -182,7 +182,7 @@ def sorbet_sigil_is_true_or_higher
 
     sig { returns(T::Boolean) }
     def typechecker_enabled?
-      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
+      DependencyDetector.instance.typechecker_for_uri?(uri) && sorbet_sigil_is_true_or_higher
     end
 
     class Scanner

lib/ruby_lsp/executor.rb

@@ -304,7 +304,8 @@ def perform_initial_indexing
 
     sig { params(uri: URI::Generic, query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
     def workspace_symbol(uri, query)
-      Requests::WorkspaceSymbol.new(query, @index, uri).perform
+      document = @store.get(uri)
+      Requests::WorkspaceSymbol.new(query, @index, document.typechecker_enabled?).perform
     end
 
     sig { params(uri: URI::Generic, range: T.nilable(T::Hash[Symbol, T.untyped])).returns({ ast: String }) }

lib/ruby_lsp/listeners/completion.rb

@@ -41,7 +41,7 @@ def on_string_node_enter(node)
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
 
         name = node.slice
         candidates = @index.prefix_search(name, @nesting)
@@ -60,7 +60,7 @@ def on_constant_read_node_enter(node)
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
 
         name = node.slice
 

lib/ruby_lsp/listeners/hover.rb

@@ -60,14 +60,14 @@ def on_constant_read_node_enter(node)
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
 
         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 DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
 
         generate_hover(node.slice, node.location)
       end

lib/ruby_lsp/listeners/signature_help.rb

@@ -13,18 +13,20 @@ class SignatureHelp
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, nesting, index, dispatcher)
+      def initialize(response_builder, nesting, index, dispatcher, typechecker_enabled)
         @response_builder = response_builder
         @nesting = nesting
         @index = index
+        @typechecker_enabled = typechecker_enabled
         dispatcher.register(self, :on_call_node_enter)
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
         return unless self_receiver?(node)
 
         message = node.message

lib/ruby_lsp/requests/signature_help.rb

@@ -70,7 +70,7 @@ def initialize(document, index, position, context, dispatcher)
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, nesting, index, dispatcher)
+        Listeners::SignatureHelp.new(@response_builder, nesting, index, dispatcher, document.typechecker_enabled?)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

lib/ruby_lsp/requests/workspace_symbol.rb

@@ -22,12 +22,12 @@ class WorkspaceSymbol < Request
       extend T::Sig
       include Support::Common
 
-      sig { params(query: T.nilable(String), index: RubyIndexer::Index, uri: URI::Generic).void }
-      def initialize(query, index, uri)
+      sig { params(query: T.nilable(String), index: RubyIndexer::Index, typechecker_enabled: T::Boolean).void }
+      def initialize(query, index, typechecker_enabled)
         super()
         @query = query
         @index = index
-        @uri = uri
+        @typechecker_enabled = typechecker_enabled
       end
 
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
@@ -36,7 +36,7 @@ def perform
           # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
           # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          next if DependencyDetector.instance.typechecker_for_uri?(@uri) && not_in_dependencies?(file_path)
+          next if @typechecker_enabled && not_in_dependencies?(file_path)
 
           # We should never show private symbols when searching the entire workspace
           next if entry.visibility == :private

test/requests/support/common_test.rb

@@ -7,27 +7,27 @@ module RubyLsp
   class CommonTest < Minitest::Test
     def test_erb_for_erb_file
       uri = URI::Generic.from_path(path: "/path/to/file.erb")
-      assert common.erb?(uri)
+      assert(common.erb?(uri))
     end
 
     def test_erb_for_html_erb_file
       uri = URI::Generic.from_path(path: "/path/to/file.html.erb")
-      assert common.erb?(uri)
+      assert(common.erb?(uri))
     end
 
     def test_erb_for_rhtml_file
       uri = URI::Generic.from_path(path: "/path/to/file.rhtml")
-      assert common.erb?(uri)
+      assert(common.erb?(uri))
     end
 
     def test_erb_for_rhtm_file
       uri = URI::Generic.from_path(path: "/path/to/file.rhtm")
-      assert common.erb?(uri)
+      assert(common.erb?(uri))
     end
 
     def test_erb_for_rb_file
       uri = URI::Generic.from_path(path: "/path/to/file.rb")
-      refute common.erb?(uri)
+      refute(common.erb?(uri))
     end
 
     private

test/requests/workspace_symbol_test.rb

@@ -6,53 +6,48 @@
 class WorkspaceSymbolTest < Minitest::Test
   def setup
     stub_no_typechecker
+    @typechecker_enabled = false
     @index = RubyIndexer::Index.new
   end
 
   def test_returns_index_entries_based_on_query
-    path = "/fake.rb"
-    uri = URI::Generic.from_path(path:)
-
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
       class Foo; end
       module Bar; end
 
       CONSTANT = 1
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo", @index, @typechecker_enabled).perform.first
     assert_equal("Foo", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CLASS, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Bar", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Bar", @index, @typechecker_enabled).perform.first
     assert_equal("Bar", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::NAMESPACE, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("CONST", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("CONST", @index, @typechecker_enabled).perform.first
     assert_equal("CONSTANT", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CONSTANT, T.must(result).kind)
   end
 
   def test_fuzzy_matches_symbols
-    path = "/fake.rb"
-    uri = URI::Generic.from_path(path:)
-
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
       class Foo; end
       module Bar; end
 
       CONSTANT = 1
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Floo", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Floo", @index, @typechecker_enabled).perform.first
     assert_equal("Foo", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CLASS, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Bear", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Bear", @index, @typechecker_enabled).perform.first
     assert_equal("Bar", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::NAMESPACE, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("CONF", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("CONF", @index, @typechecker_enabled).perform.first
     assert_equal("CONSTANT", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CONSTANT, T.must(result).kind)
   end
@@ -67,59 +62,50 @@ class Foo; end
     RUBY
 
     path = "#{Bundler.bundle_path}/gems/fake-gem-0.1.0/lib/gem_symbol_foo.rb"
-    uri = URI::Generic.from_path(path:)
     @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
       class Foo; end
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo", @index, uri).perform
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo", @index, true).perform
     assert_equal(1, result.length)
-    assert_equal(uri.to_s, T.must(result.first).location.uri)
+    assert_equal(URI::Generic.from_path(path: path).to_s, T.must(result.first).location.uri)
   end
 
   def test_symbols_include_container_name
-    path = "/fake.rb"
-    uri = URI::Generic.from_path(path:)
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
       module Foo
         class Bar; end
       end
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo::Bar", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo::Bar", @index, @typechecker_enabled).perform.first
     assert_equal("Foo::Bar", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CLASS, T.must(result).kind)
     assert_equal("Foo", T.must(result).container_name)
   end
 
   def test_finds_default_gem_symbols
-    path = "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb"
-    uri = URI::Generic.from_path(path:)
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path))
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb"))
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Pathname", @index, uri).perform
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Pathname", @index, @typechecker_enabled).perform
     refute_empty(result)
   end
 
   def test_does_not_include_private_constants
-    path = "/fake.rb"
-    uri = URI::Generic.from_path(path:)
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
       class Foo
         CONSTANT = 1
         private_constant(:CONSTANT)
       end
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo::CONSTANT", @index, uri).perform
+    result = RubyLsp::Requests::WorkspaceSymbol.new("Foo::CONSTANT", @index, @typechecker_enabled).perform
     assert_equal(1, result.length)
     assert_equal("Foo", T.must(result.first).name)
   end
 
   def test_returns_method_symbols
-    path = "/fake.rb"
-    uri = URI::Generic.from_path(path:)
-    @index.index_single(RubyIndexer::IndexablePath.new(nil, path), <<~RUBY)
+    @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
       class Foo
         attr_reader :baz
 
@@ -128,15 +114,15 @@ def bar; end
       end
     RUBY
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("bar", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("bar", @index, @typechecker_enabled).perform.first
     assert_equal("bar", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::METHOD, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("initialize", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("initialize", @index, @typechecker_enabled).perform.first
     assert_equal("initialize", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::CONSTRUCTOR, T.must(result).kind)
 
-    result = RubyLsp::Requests::WorkspaceSymbol.new("baz", @index, uri).perform.first
+    result = RubyLsp::Requests::WorkspaceSymbol.new("baz", @index, @typechecker_enabled).perform.first
     assert_equal("baz", T.must(result).name)
     assert_equal(RubyLsp::Constant::SymbolKind::PROPERTY, T.must(result).kind)
   end