Support Sorbet typed: false files for completion requests

lib/ruby_lsp/document.rb

@@ -177,6 +177,18 @@ def locate(node, char_position, node_types: [])
       [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
     end
 
+    sig { returns(T::Boolean) }
+    def sorbet_sigil_is_true_or_higher
+      parse_result.magic_comments.any? do |comment|
+        comment.key == "typed" && ["true", "strict", "strong"].include?(comment.value)
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def typechecker_enabled?
+      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
+    end
+
     class Scanner
       extend T::Sig
 

lib/ruby_lsp/executor.rb

@@ -515,7 +515,7 @@ def completion(uri, position)
       return unless target
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::Completion.new(@index, nesting, dispatcher)
+      listener = Requests::Completion.new(@index, nesting, dispatcher, document.typechecker_enabled?)
       dispatcher.dispatch_once(target)
       listener.response
     end

lib/ruby_lsp/requests/completion.rb

@@ -36,13 +36,15 @@ class Completion < Listener
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(index, nesting, dispatcher)
+      def initialize(index, nesting, dispatcher, typechecker_enabled)
         super(dispatcher)
         @_response = T.let([], ResponseType)
         @index = index
         @nesting = nesting
+        @typechecker_enabled = typechecker_enabled
 
         dispatcher.register(
           self,
@@ -63,7 +65,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)
@@ -82,7 +84,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
 
@@ -125,7 +127,7 @@ def on_constant_path_node_enter(node)
 
       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)
 
         name = node.message

test/requests/completion_test.rb

@@ -9,7 +9,6 @@ def setup
     @uri = URI("file:///fake.rb")
     @store = RubyLsp::Store.new
     @executor = RubyLsp::Executor.new(@store, @message_queue)
-    stub_no_typechecker
   end
 
   def teardown
@@ -338,7 +337,6 @@ class A
   end
 
   def test_completion_for_aliased_constants
-    stub_no_typechecker
     document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: @uri)
       module A
         module B
@@ -370,7 +368,6 @@ module Other
   end
 
   def test_completion_for_aliased_complex_constants
-    stub_no_typechecker
     document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: @uri)
       module A
         module B
@@ -403,7 +400,6 @@ module Other
   end
 
   def test_completion_uses_shortest_possible_name_for_filter_text
-    stub_no_typechecker
     document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: @uri)
       module A
         module B
@@ -542,6 +538,50 @@ def qux
     assert_equal(["bar", "bar=(bar)"], result.map { |completion| completion.text_edit.new_text })
   end
 
+  def test_with_typed_false
+    document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: @uri)
+      # typed: false
+      class Foo
+      end
+
+      F
+    RUBY
+
+    end_position = { line: 4, character: 1 }
+    @store.set(uri: @uri, source: document.source, version: 1)
+
+    index = @executor.instance_variable_get(:@index)
+    index.index_single(RubyIndexer::IndexablePath.new(nil, @uri.to_standardized_path), document.source)
+
+    result = run_request(
+      method: "textDocument/completion",
+      params: { textDocument: { uri: @uri.to_s }, position: end_position },
+    )
+    assert_equal(["Foo"], result.map(&:label))
+  end
+
+  def test_with_typed_true
+    document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: @uri)
+      # typed: true
+      class Foo
+      end
+
+      F
+    RUBY
+
+    end_position = { line: 4, character: 1 }
+    @store.set(uri: @uri, source: document.source, version: 1)
+
+    index = @executor.instance_variable_get(:@index)
+    index.index_single(RubyIndexer::IndexablePath.new(nil, @uri.to_standardized_path), document.source)
+
+    result = run_request(
+      method: "textDocument/completion",
+      params: { textDocument: { uri: @uri.to_s }, position: end_position },
+    )
+    assert_empty(result)
+  end
+
   private
 
   def run_request(method:, params: {})

test/ruby_document_test.rb

@@ -536,6 +536,65 @@ def test_cache_set_and_get
     assert_equal(value, document.cache_get("textDocument/semanticHighlighting"))
   end
 
+  def test_no_sigil
+    document = RubyLsp::RubyDocument.new(
+      source: +"# frozen_string_literal: true",
+      version: 1,
+      uri: URI("file:///foo/bar.rb"),
+    )
+    refute_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sigil_ignore
+    document = RubyLsp::RubyDocument.new(source: +"# typed: ignored", version: 1, uri: URI("file:///foo/bar.rb"))
+    refute_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sigil_false
+    document = RubyLsp::RubyDocument.new(source: +"# typed: false", version: 1, uri: URI("file:///foo/bar.rb"))
+    refute_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sigil_true
+    document = RubyLsp::RubyDocument.new(source: +"# typed: true", version: 1, uri: URI("file:///foo/bar.rb"))
+    assert_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sigil_strict
+    document = RubyLsp::RubyDocument.new(source: +"# typed: strict", version: 1, uri: URI("file:///foo/bar.rb"))
+    assert_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sigil_strong
+    document = RubyLsp::RubyDocument.new(source: +"# typed: strong", version: 1, uri: URI("file:///foo/bar.rb"))
+    assert_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
+  def test_sorbet_sigil_only_in_magic_comment
+    document = RubyLsp::RubyDocument.new(source: +<<~RUBY, version: 1, uri: URI("file:///foo/bar.rb"))
+      # typed: false
+
+      def foo
+        some_string = "# typed: true"
+      end
+
+      # Shouldn't be tricked by the following comment:
+      # ```
+      # # typed: strict
+      #
+      # def main; end
+      # ```
+      def bar; end
+
+      def baz
+        <<-CODE
+          # typed: strong
+        CODE
+      end
+    RUBY
+    refute_predicate(document, :sorbet_sigil_is_true_or_higher)
+  end
+
   private
 
   def assert_error_edit(actual, error_range)