ruby-lsp 0.23.12 → 0.23.13

data/lib/ruby_lsp/listeners/hover.rb

@@ -6,55 +6,49 @@ module RubyLsp
     class Hover
       include Requests::Support::Common
 
-      ALLOWED_TARGETS = T.let(
-        [
-          Prism::CallNode,
-          Prism::ConstantReadNode,
-          Prism::ConstantWriteNode,
-          Prism::ConstantPathNode,
-          Prism::GlobalVariableAndWriteNode,
-          Prism::GlobalVariableOperatorWriteNode,
-          Prism::GlobalVariableOrWriteNode,
-          Prism::GlobalVariableReadNode,
-          Prism::GlobalVariableTargetNode,
-          Prism::GlobalVariableWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode,
-          Prism::SymbolNode,
-          Prism::StringNode,
-          Prism::InterpolatedStringNode,
-          Prism::SuperNode,
-          Prism::ForwardingSuperNode,
-          Prism::YieldNode,
-          Prism::ClassVariableAndWriteNode,
-          Prism::ClassVariableOperatorWriteNode,
-          Prism::ClassVariableOrWriteNode,
-          Prism::ClassVariableReadNode,
-          Prism::ClassVariableTargetNode,
-          Prism::ClassVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      ALLOWED_REMOTE_PROVIDERS = T.let(
-        [
-          "https://github.com",
-          "https://gitlab.com",
-        ].freeze,
-        T::Array[String],
-      )
+      ALLOWED_TARGETS = [
+        Prism::CallNode,
+        Prism::ConstantReadNode,
+        Prism::ConstantWriteNode,
+        Prism::ConstantPathNode,
+        Prism::GlobalVariableAndWriteNode,
+        Prism::GlobalVariableOperatorWriteNode,
+        Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableReadNode,
+        Prism::GlobalVariableTargetNode,
+        Prism::GlobalVariableWriteNode,
+        Prism::InstanceVariableReadNode,
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableTargetNode,
+        Prism::InstanceVariableWriteNode,
+        Prism::SymbolNode,
+        Prism::StringNode,
+        Prism::InterpolatedStringNode,
+        Prism::SuperNode,
+        Prism::ForwardingSuperNode,
+        Prism::YieldNode,
+        Prism::ClassVariableAndWriteNode,
+        Prism::ClassVariableOperatorWriteNode,
+        Prism::ClassVariableOrWriteNode,
+        Prism::ClassVariableReadNode,
+        Prism::ClassVariableTargetNode,
+        Prism::ClassVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      ALLOWED_REMOTE_PROVIDERS = [
+        "https://github.com",
+        "https://gitlab.com",
+      ].freeze #: Array[String]
 
       #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
       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))
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
+        @path = uri.to_standardized_path #: String?
         @node_context = node_context
         @sorbet_level = sorbet_level
 
@@ -387,14 +381,11 @@ module RubyLsp
         spec = Gem::Specification.find_by_name(first_argument.content)
         return unless spec
 
-        info = T.let(
-          [
-            spec.description,
-            spec.summary,
-            "This rubygem does not have a description or summary.",
-          ].find { |text| !text.nil? && !text.empty? },
-          String,
-        )
+        info = [
+          spec.description,
+          spec.summary,
+          "This rubygem does not have a description or summary.",
+        ].find { |text| !text.nil? && !text.empty? } #: String
 
         # Remove leading whitespace if a heredoc was used for the summary or description
         info = info.gsub(/^ +/, "")

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -6,7 +6,7 @@ module RubyLsp
     class InlayHints
       include Requests::Support::Common
 
-      RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
+      RESCUE_STRING_LENGTH = "rescue".length #: Integer
 
       #: (ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint] response_builder, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, hints_configuration, dispatcher)

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -6,24 +6,21 @@ module RubyLsp
     class SemanticHighlighting
       include Requests::Support::Common
 
-      SPECIAL_RUBY_METHODS = T.let(
-        [
-          Module.instance_methods(false),
-          Kernel.instance_methods(false),
-          Kernel.methods(false),
-          Bundler::Dsl.instance_methods(false),
-          Module.private_instance_methods(false),
-        ].flatten.map(&:to_s).freeze,
-        T::Array[String],
-      )
+      SPECIAL_RUBY_METHODS = [
+        Module.instance_methods(false),
+        Kernel.instance_methods(false),
+        Kernel.methods(false),
+        Bundler::Dsl.instance_methods(false),
+        Module.private_instance_methods(false),
+      ].flatten.map(&:to_s).freeze #: Array[String]
 
       #: (Prism::Dispatcher dispatcher, ResponseBuilders::SemanticHighlighting response_builder) -> void
       def initialize(dispatcher, response_builder)
         @response_builder = response_builder
-        @special_methods = T.let(nil, T.nilable(T::Array[String]))
-        @current_scope = T.let(Scope.new, Scope)
-        @inside_regex_capture = T.let(false, T::Boolean)
-        @inside_implicit_node = T.let(false, T::Boolean)
+        @special_methods = nil #: Array[String]?
+        @current_scope = Scope.new #: Scope
+        @inside_regex_capture = false #: bool
+        @inside_implicit_node = false #: bool
 
         dispatcher.register(
           self,

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -11,8 +11,8 @@ module RubyLsp
         @sorbet_level = sorbet_level
         @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)
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
       end

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -3,28 +3,20 @@
 
 module RubyLsp
   module Listeners
-    class SpecStyle
+    class SpecStyle < TestDiscovery
       extend T::Sig
-      include Requests::Support::Common
-
-      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
 
       #: (response_builder: ResponseBuilders::TestCollection, global_state: GlobalState, dispatcher: Prism::Dispatcher, uri: URI::Generic) -> void
       def initialize(response_builder, global_state, dispatcher, uri)
-        @response_builder = response_builder
-        @uri = uri
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @visibility_stack = T.let([:public], T::Array[Symbol])
-        @nesting = T.let([], T::Array[String])
-        @describe_block_nesting = T.let([], T::Array[String])
-        @spec_class_stack = T.let([], T::Array[T::Boolean])
+        super
+
+        @describe_block_nesting = [] #: Array[String]
+        @spec_class_stack = [] #: Array[bool]
 
         dispatcher.register(
           self,
+          # Common handlers registered in parent class
           :on_class_node_enter,
-          :on_class_node_leave,
-          :on_module_node_enter,
-          :on_module_node_leave,
           :on_call_node_enter, # e.g. `describe` or `it`
           :on_call_node_leave,
         )
@@ -32,46 +24,16 @@ module RubyLsp
 
       #: (node: Prism::ClassNode) -> void
       def on_class_node_enter(node)
-        @visibility_stack << :public
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        fully_qualified_name = RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
-
-        attached_ancestors = begin
-          @index.linearized_ancestors_of(fully_qualified_name)
-        rescue RubyIndexer::Index::NonExistingNamespaceError
-          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
-          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
-          [node.superclass&.slice].compact
+        with_test_ancestor_tracking(node) do |_, ancestors|
+          is_spec = ancestors.include?("Minitest::Spec")
+          @spec_class_stack.push(is_spec)
         end
-
-        is_spec = attached_ancestors.include?("Minitest::Spec")
-        @spec_class_stack.push(is_spec)
-
-        @nesting << name
-      end
-
-      #: (node: Prism::ModuleNode) -> void
-      def on_module_node_enter(node)
-        @visibility_stack << :public
-
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        @nesting << name
-      end
-
-      #: (node: Prism::ModuleNode) -> void
-      def on_module_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
       end
 
       #: (node: Prism::ClassNode) -> void
-      def on_class_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        super
+
         @spec_class_stack.pop
       end
 
@@ -109,7 +71,7 @@ module RubyLsp
             description,
             @uri,
             range_from_node(node),
-            tags: [:minitest],
+            framework: :minitest,
           )
           @response_builder.add(test_item)
         else
@@ -141,7 +103,7 @@ module RubyLsp
           description,
           @uri,
           range_from_node(node),
-          tags: [:minitest],
+          framework: :minitest,
         )
         parent_test_group.add(test_item)
       end
@@ -155,7 +117,7 @@ module RubyLsp
         end
         return unless root_group_name
 
-        test_group = T.let(@response_builder[root_group_name], T.nilable(Requests::Support::TestItem))
+        test_group = @response_builder[root_group_name] #: Requests::Support::TestItem?
         return unless test_group
 
         return test_group unless nested_describe_groups
@@ -188,12 +150,6 @@ module RubyLsp
 
         T.must(@spec_class_stack.last)
       end
-
-      #: (node: Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) -> String
-      def name_with_dynamic_reference(node)
-        slice = node.slice
-        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
-      end
     end
   end
 end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class TestDiscovery
+      extend T::Helpers
+      abstract!
+
+      include Requests::Support::Common
+
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def initialize(response_builder, global_state, dispatcher, uri)
+        @response_builder = response_builder
+        @uri = uri
+        @index = global_state.index #: RubyIndexer::Index
+        @visibility_stack = [:public] #: Array[Symbol]
+        @nesting = [] #: Array[String]
+
+        dispatcher.register(
+          self,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node)
+        @visibility_stack << :public
+
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        @nesting << name
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      private
+
+      #: (String? name) -> String
+      def calc_fully_qualified_name(name)
+        RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+      end
+
+      #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]
+      def calc_attached_ancestors(node, fully_qualified_name)
+        @index.linearized_ancestors_of(fully_qualified_name)
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
+        # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
+        [node.superclass&.slice].compact
+      end
+
+      #: (Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode node) -> String
+      def name_with_dynamic_reference(node)
+        slice = node.slice
+        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
+      end
+
+      #: (Prism::ClassNode node, ^(String name, Array[String] ancestors) -> void block) -> void
+      def with_test_ancestor_tracking(node, &block)
+        @visibility_stack << :public
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        fully_qualified_name = calc_fully_qualified_name(name)
+        attached_ancestors = calc_attached_ancestors(node, fully_qualified_name)
+
+        block.call(fully_qualified_name, attached_ancestors)
+
+        @nesting << name
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/test_style.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Listeners
-    class TestStyle
+    class TestStyle < TestDiscovery
       class << self
         # Resolves the minimal set of commands required to execute the requested tests
         #: (Array[Hash[Symbol, untyped]]) -> Array[String]
@@ -24,6 +24,7 @@ module RubyLsp
           until queue.empty?
             item = T.must(queue.shift)
             tags = Set.new(item[:tags])
+            next unless tags.include?("framework:minitest") || tags.include?("framework:test_unit")
 
             children = item[:children]
             uri = URI(item[:uri])
@@ -31,7 +32,12 @@ module RubyLsp
             next unless path
 
             if tags.include?("test_dir")
-              full_files << "#{path}/**/*" if children.empty?
+              if children.empty?
+                full_files.concat(Dir.glob(
+                  "#{path}/**/{*_test,test_*}.rb",
+                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                ))
+              end
             elsif tags.include?("test_file")
               full_files << path if children.empty?
             elsif tags.include?("test_group")
@@ -40,7 +46,7 @@ module RubyLsp
               unless children.any? && children.all? { |child| child[:tags].include?("test_group") }
                 aggregated_tests[path][item[:label]] = { tags: tags, examples: [] }
               end
-            elsif tags.include?("minitest") || tags.include?("test_unit")
+            else
               class_name, method_name = item[:id].split("#")
               aggregated_tests[path][class_name][:examples] << method_name
               aggregated_tests[path][class_name][:tags].merge(tags)
@@ -55,7 +61,7 @@ module RubyLsp
             # Separate groups into Minitest and Test Unit. You can have both frameworks in the same file, but you cannot
             # have a group belongs to both at the same time
             minitest_groups, test_unit_groups = groups_and_examples.partition do |_, info|
-              info[:tags].include?("minitest")
+              info[:tags].include?("framework:minitest")
             end
 
             if minitest_groups.any?
@@ -67,7 +73,10 @@ module RubyLsp
             end
           end
 
-          commands << "#{BASE_COMMAND} -Itest #{full_files.join(" ")}" unless full_files.empty?
+          unless full_files.empty?
+            commands << "#{BASE_COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{full_files.join(" ")}"
+          end
+
           commands
         end
 
@@ -77,7 +86,10 @@ module RubyLsp
         def handle_minitest_groups(file_path, groups_and_examples)
           regexes = groups_and_examples.flat_map do |group, info|
             examples = info[:examples]
-            group_regex = Shellwords.escape(group).gsub(Shellwords.escape(DYNAMIC_REFERENCE_MARKER), ".*")
+            group_regex = Shellwords.escape(group).gsub(
+              Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
+              ".*",
+            )
             if examples.empty?
               "^#{group_regex}(#|::)"
             elsif examples.length == 1
@@ -100,7 +112,10 @@ module RubyLsp
         def handle_test_unit_groups(file_path, groups_and_examples)
           groups_and_examples.map do |group, info|
             examples = info[:examples]
-            group_regex = Shellwords.escape(group).gsub(Shellwords.escape(DYNAMIC_REFERENCE_MARKER), ".*")
+            group_regex = Shellwords.escape(group).gsub(
+              Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
+              ".*",
+            )
             command = +"#{BASE_COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}$/\""
 
             unless examples.empty?
@@ -118,33 +133,26 @@ module RubyLsp
 
       include Requests::Support::Common
 
+      MINITEST_REPORTER_PATH = File.expand_path("../ruby_lsp_reporter_plugin.rb", __dir__) #: String
+      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_unit_test_runner.rb", __dir__) #: String
       ACCESS_MODIFIERS = [:public, :private, :protected].freeze
-      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
-      BASE_COMMAND = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_lockfile }
-          "bundle exec ruby"
-        rescue Bundler::GemfileNotFound
-          "ruby"
-        end,
-        String,
-      )
+      BASE_COMMAND = begin
+        Bundler.with_original_env { Bundler.default_lockfile }
+        "bundle exec ruby"
+      rescue Bundler::GemfileNotFound
+        "ruby"
+      end #: String
 
       #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def initialize(response_builder, global_state, dispatcher, uri)
-        @response_builder = response_builder
-        @uri = uri
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @visibility_stack = T.let([:public], T::Array[Symbol])
-        @nesting = T.let([], T::Array[String])
-        @framework_tag = T.let(:minitest, Symbol)
+        super
+
+        @framework = :minitest #: Symbol
 
         dispatcher.register(
           self,
+          # Common handlers registered in parent class
           :on_class_node_enter,
-          :on_class_node_leave,
-          :on_module_node_enter,
-          :on_module_node_leave,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_call_node_leave,
@@ -153,55 +161,19 @@ module RubyLsp
 
       #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
-        @visibility_stack << :public
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        fully_qualified_name = RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
-
-        attached_ancestors = begin
-          @index.linearized_ancestors_of(fully_qualified_name)
-        rescue RubyIndexer::Index::NonExistingNamespaceError
-          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
-          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
-          [node.superclass&.slice].compact
-        end
-
-        @framework_tag = :test_unit if attached_ancestors.include?("Test::Unit::TestCase")
-
-        if @framework_tag == :test_unit || non_declarative_minitest?(attached_ancestors, fully_qualified_name)
-          @response_builder.add(Requests::Support::TestItem.new(
-            fully_qualified_name,
-            fully_qualified_name,
-            @uri,
-            range_from_node(node),
-            tags: [@framework_tag],
-          ))
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          @framework = :test_unit if ancestors.include?("Test::Unit::TestCase")
+
+          if @framework == :test_unit || non_declarative_minitest?(ancestors, name)
+            @response_builder.add(Requests::Support::TestItem.new(
+              name,
+              name,
+              @uri,
+              range_from_node(node),
+              framework: @framework,
+            ))
+          end
         end
-
-        @nesting << name
-      end
-
-      #: (Prism::ModuleNode node) -> void
-      def on_module_node_enter(node)
-        @visibility_stack << :public
-
-        name = constant_name(node.constant_path)
-        name ||= name_with_dynamic_reference(node.constant_path)
-
-        @nesting << name
-      end
-
-      #: (Prism::ModuleNode node) -> void
-      def on_module_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
-      end
-
-      #: (Prism::ClassNode node) -> void
-      def on_class_node_leave(node)
-        @visibility_stack.pop
-        @nesting.pop
       end
 
       #: (Prism::DefNode node) -> void
@@ -224,7 +196,7 @@ module RubyLsp
           name,
           @uri,
           range_from_node(node),
-          tags: [@framework_tag],
+          framework: @framework,
         ))
       end
 
@@ -259,12 +231,6 @@ module RubyLsp
       rescue RubyIndexer::Index::NonExistingNamespaceError
         true
       end
-
-      #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String
-      def name_with_dynamic_reference(node)
-        slice = node.slice
-        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
-      end
     end
   end
 end

data/lib/ruby_lsp/node_context.rb

@@ -25,13 +25,13 @@ module RubyLsp
       @call_node = call_node
 
       nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
-      @nesting = T.let(nesting, T::Array[String])
-      @surrounding_method = T.let(surrounding_method, T.nilable(String))
+      @nesting = nesting #: Array[String]
+      @surrounding_method = surrounding_method #: String?
     end
 
     #: -> String
     def fully_qualified_name
-      @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
+      @fully_qualified_name ||= @nesting.join("::") #: String?
     end
 
     #: -> Array[Symbol]
@@ -55,7 +55,7 @@ module RubyLsp
     #: (Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] nodes) -> [Array[String], String?]
     def handle_nesting_nodes(nodes)
       nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
+      surrounding_method = nil #: String?
 
       @nesting_nodes.each do |node|
         case node

data/lib/ruby_lsp/rbs_document.rb

@@ -9,7 +9,7 @@ module RubyLsp
 
     #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
-      @syntax_error = T.let(false, T::Boolean)
+      @syntax_error = false #: bool
       super
     end