ruby-lsp 0.23.11 → 0.23.17

data/lib/ruby_lsp/requests/support/common.rb

@@ -8,12 +8,11 @@ module RubyLsp
         # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
         # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
-        extend T::Sig
         extend T::Helpers
 
         requires_ancestor { Kernel }
 
-        sig { params(node: Prism::Node).returns(Interface::Range) }
+        #: (Prism::Node node) -> Interface::Range
         def range_from_node(node)
           loc = node.location
 
@@ -26,7 +25,7 @@ module RubyLsp
           )
         end
 
-        sig { params(location: T.any(Prism::Location, RubyIndexer::Location)).returns(Interface::Range) }
+        #: ((Prism::Location | RubyIndexer::Location) location) -> Interface::Range
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -37,15 +36,7 @@ module RubyLsp
           )
         end
 
-        sig do
-          params(
-            node: Prism::Node,
-            title: String,
-            command_name: String,
-            arguments: T.nilable(T::Array[T.untyped]),
-            data: T.nilable(T::Hash[T.untyped, T.untyped]),
-          ).returns(Interface::CodeLens)
-        end
+        #: (Prism::Node node, title: String, command_name: String, arguments: Array[untyped]?, data: Hash[untyped, untyped]?) -> Interface::CodeLens
         def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)
 
@@ -60,26 +51,22 @@ module RubyLsp
           )
         end
 
-        sig { params(file_path: String).returns(T.nilable(T::Boolean)) }
+        #: (String file_path) -> bool?
         def not_in_dependencies?(file_path)
           BUNDLE_PATH &&
-            !file_path.start_with?(T.must(BUNDLE_PATH)) &&
+            !file_path.start_with?(
+              BUNDLE_PATH, #: as !nil
+            ) &&
             !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def self_receiver?(node)
           receiver = node.receiver
           receiver.nil? || receiver.is_a?(Prism::SelfNode)
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-          ).returns(T::Hash[Symbol, String])
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries) -> Hash[Symbol, String]
         def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
@@ -112,14 +99,7 @@ module RubyLsp
           }
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-            extra_links: T.nilable(String),
-          ).returns(String)
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries, ?extra_links: String?) -> String
         def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
@@ -135,22 +115,12 @@ module RubyLsp
           MARKDOWN
         end
 
-        sig do
-          params(
-            node: T.any(
-              Prism::ConstantPathNode,
-              Prism::ConstantReadNode,
-              Prism::ConstantPathTargetNode,
-              Prism::CallNode,
-              Prism::MissingNode,
-            ),
-          ).returns(T.nilable(String))
-        end
+        #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
         def constant_name(node)
           RubyIndexer::Index.constant_name(node)
         end
 
-        sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }
+        #: ((Prism::ModuleNode | Prism::ClassNode) node) -> String?
         def namespace_constant_name(node)
           path = node.constant_path
           case path
@@ -162,14 +132,9 @@ module RubyLsp
         # Iterates over each part of a constant path, so that we can easily push response items for each section of the
         # name. For example, for `Foo::Bar::Baz`, this method will invoke the block with `Foo`, then `Bar` and finally
         # `Baz`.
-        sig do
-          params(
-            node: Prism::Node,
-            block: T.proc.params(part: Prism::Node).void,
-          ).void
-        end
+        #: (Prism::Node node) { (Prism::Node part) -> void } -> void
         def each_constant_path_part(node, &block)
-          current = T.let(node, T.nilable(Prism::Node))
+          current = node #: Prism::Node?
 
           while current.is_a?(Prism::ConstantPathNode)
             block.call(current)
@@ -177,7 +142,7 @@ module RubyLsp
           end
         end
 
-        sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
+        #: (RubyIndexer::Entry entry) -> Integer?
         def kind_for_entry(entry)
           case entry
           when RubyIndexer::Entry::Class
@@ -194,11 +159,6 @@ module RubyLsp
             Constant::SymbolKind::FIELD
           end
         end
-
-        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
-        def sorbet_level_true_or_higher?(sorbet_level)
-          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
-        end
       end
     end
   end

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -5,40 +5,32 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopDiagnostic
-        extend T::Sig
-
-        RUBOCOP_TO_LSP_SEVERITY = T.let(
-          {
-            info: Constant::DiagnosticSeverity::HINT,
-            refactor: Constant::DiagnosticSeverity::INFORMATION,
-            convention: Constant::DiagnosticSeverity::INFORMATION,
-            warning: Constant::DiagnosticSeverity::WARNING,
-            error: Constant::DiagnosticSeverity::ERROR,
-            fatal: Constant::DiagnosticSeverity::ERROR,
-          }.freeze,
-          T::Hash[Symbol, Integer],
-        )
-
-        ENHANCED_DOC_URL = T.let(
-          begin
-            gem("rubocop", ">= 1.64.0")
-            true
-          rescue LoadError
-            false
-          end,
-          T::Boolean,
-        )
+        RUBOCOP_TO_LSP_SEVERITY = {
+          info: Constant::DiagnosticSeverity::HINT,
+          refactor: Constant::DiagnosticSeverity::INFORMATION,
+          convention: Constant::DiagnosticSeverity::INFORMATION,
+          warning: Constant::DiagnosticSeverity::WARNING,
+          error: Constant::DiagnosticSeverity::ERROR,
+          fatal: Constant::DiagnosticSeverity::ERROR,
+        }.freeze #: Hash[Symbol, Integer]
+
+        ENHANCED_DOC_URL = begin
+          gem("rubocop", ">= 1.64.0")
+          true
+        rescue LoadError
+          false
+        end #: bool
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: RubyDocument, offense: ::RuboCop::Cop::Offense, uri: URI::Generic).void }
+        #: (RubyDocument document, ::RuboCop::Cop::Offense offense, URI::Generic uri) -> void
         def initialize(document, offense, uri)
           @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(T::Array[Interface::CodeAction]) }
+        #: -> Array[Interface::CodeAction]
         def to_lsp_code_actions
           code_actions = []
 
@@ -48,7 +40,7 @@ module RubyLsp
           code_actions
         end
 
-        sig { params(config: ::RuboCop::Config).returns(Interface::Diagnostic) }
+        #: (::RuboCop::Config config) -> Interface::Diagnostic
         def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
@@ -78,19 +70,19 @@ module RubyLsp
 
         private
 
-        sig { returns(String) }
+        #: -> String
         def message
           message  = @offense.message
           message += "\n\nThis offense is not auto-correctable.\n" unless correctable?
           message
         end
 
-        sig { returns(T.nilable(Integer)) }
+        #: -> Integer?
         def severity
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { params(config: ::RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        #: (::RuboCop::Config config) -> Interface::CodeDescription?
         def code_description(config)
           cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
           return unless cop
@@ -103,7 +95,7 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def autocorrect_action
           Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
@@ -123,7 +115,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
             Interface::TextEdit.new(
@@ -136,7 +128,7 @@ module RubyLsp
           end
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def disable_line_action
           Interface::CodeAction.new(
             title: "Disable #{@offense.cop_name} for this line",
@@ -155,7 +147,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def line_disable_comment
           new_text = if @offense.source_line.include?(" # rubocop:disable ")
             ",#{@offense.cop_name}"
@@ -178,7 +170,7 @@ module RubyLsp
           [inline_comment]
         end
 
-        sig { params(line: String).returns(Integer) }
+        #: (String line) -> Integer
         def length_of_line(line)
           if @document.encoding == Encoding::UTF_16LE
             line_length = 0
@@ -197,7 +189,7 @@ module RubyLsp
         # When `RuboCop::LSP.enable` is called, contextual autocorrect will not offer itself
         # as `correctable?` to prevent annoying changes while typing. Instead check if
         # a corrector is present. If it is, then that means some code transformation can be applied.
-        sig { returns(T::Boolean) }
+        #: -> bool
         def correctable?
           !@offense.corrector.nil?
         end

data/lib/ruby_lsp/requests/support/rubocop_formatter.rb

@@ -9,19 +9,19 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopFormatter
-        extend T::Sig
         include Formatter
 
-        sig { void }
+        #: -> void
         def initialize
-          @diagnostic_runner = T.let(RuboCopRunner.new, RuboCopRunner)
+          @diagnostic_runner = RuboCopRunner.new #: RuboCopRunner
           # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
-          @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
+          @format_runner = RuboCopRunner.new("-a") #: RuboCopRunner
         end
 
-        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
 
           # Invoke RuboCop with just this file in `paths`
           @format_runner.run(filename, document.source)
@@ -29,19 +29,16 @@ module RubyLsp
         end
 
         # RuboCop does not support range formatting
-        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, String source, Integer base_indentation) -> String?
         def run_range_formatting(uri, source, base_indentation)
           nil
         end
 
-        sig do
-          override.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
-        end
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
           # Invoke RuboCop with just this file in `paths`
           @diagnostic_runner.run(filename, document.source)
 

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -32,15 +32,13 @@ module RubyLsp
   module Requests
     module Support
       class InternalRuboCopError < StandardError
-        extend T::Sig
-
         MESSAGE = <<~EOS
           An internal error occurred %s.
           Updating to a newer version of RuboCop may solve this.
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: T.any(::RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
+        #: ((::RuboCop::ErrorWithAnalyzedFileLocation | StandardError) rubocop_error) -> void
         def initialize(rubocop_error)
           message = case rubocop_error
           when ::RuboCop::ErrorWithAnalyzedFileLocation
@@ -54,24 +52,19 @@ module RubyLsp
 
       # :nodoc:
       class RuboCopRunner < ::RuboCop::Runner
-        extend T::Sig
-
         class ConfigurationError < StandardError; end
 
-        DEFAULT_ARGS = T.let(
-          [
-            "--stderr", # Print any output to stderr so that our stdout does not get polluted
-            "--force-exclusion",
-            "--format",
-            "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-          ],
-          T::Array[String],
-        )
-
-        sig { returns(T::Array[::RuboCop::Cop::Offense]) }
+        DEFAULT_ARGS = [
+          "--stderr", # Print any output to stderr so that our stdout does not get polluted
+          "--force-exclusion",
+          "--format",
+          "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+        ] #: Array[String]
+
+        #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
-        sig { returns(::RuboCop::Config) }
+        #: ::RuboCop::Config
         attr_reader :config_for_working_directory
 
         begin
@@ -82,24 +75,24 @@ module RubyLsp
         end
         DEFAULT_ARGS.freeze
 
-        sig { params(args: String).void }
+        #: (*String args) -> void
         def initialize(*args)
-          @options = T.let({}, T::Hash[Symbol, T.untyped])
-          @offenses = T.let([], T::Array[::RuboCop::Cop::Offense])
-          @errors = T.let([], T::Array[String])
-          @warnings = T.let([], T::Array[String])
+          @options = {} #: Hash[Symbol, untyped]
+          @offenses = [] #: Array[::RuboCop::Cop::Offense]
+          @errors = [] #: Array[String]
+          @warnings = [] #: Array[String]
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
 
           config_store = ::RuboCop::ConfigStore.new
           config_store.options_config = rubocop_options[:config] if rubocop_options[:config]
-          @config_for_working_directory = T.let(config_store.for_pwd, ::RuboCop::Config)
+          @config_for_working_directory = config_store.for_pwd #: ::RuboCop::Config
 
           super(rubocop_options, config_store)
         end
 
-        sig { params(path: String, contents: String).void }
+        #: (String path, String contents) -> void
         def run(path, contents)
           # Clear Runner state between runs since we get a single instance of this class
           # on every use site.
@@ -121,33 +114,28 @@ module RubyLsp
           raise InternalRuboCopError, error
         end
 
-        sig { returns(String) }
+        #: -> String
         def formatted_source
           @options[:stdin]
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(cop_name: String).returns(T.nilable(T.class_of(::RuboCop::Cop::Base))) }
+          #: (String cop_name) -> singleton(::RuboCop::Cop::Base)?
           def find_cop_by_name(cop_name)
             cop_registry[cop_name]&.first
           end
 
           private
 
-          sig { returns(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]) }
+          #: -> Hash[String, [singleton(::RuboCop::Cop::Base)]]
           def cop_registry
-            @cop_registry ||= T.let(
-              ::RuboCop::Cop::Registry.global.to_h,
-              T.nilable(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]),
-            )
+            @cop_registry ||= ::RuboCop::Cop::Registry.global.to_h #: Hash[String, [singleton(::RuboCop::Cop::Base)]]?
           end
         end
 
         private
 
-        sig { params(_file: String, offenses: T::Array[::RuboCop::Cop::Offense]).void }
+        #: (String _file, Array[::RuboCop::Cop::Offense] offenses) -> void
         def file_finished(_file, offenses)
           @offenses = offenses
         end

data/lib/ruby_lsp/requests/support/selection_range.rb

@@ -5,9 +5,7 @@ module RubyLsp
   module Requests
     module Support
       class SelectionRange < Interface::SelectionRange
-        extend T::Sig
-
-        sig { params(position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+        #: (Hash[Symbol, untyped] position) -> bool
         def cover?(position)
           start_covered = range.start.line < position[:line] ||
             (range.start.line == position[:line] && range.start.character <= position[:character])

data/lib/ruby_lsp/requests/support/sorbet.rb

@@ -6,45 +6,36 @@ module RubyLsp
     module Support
       class Sorbet
         class << self
-          extend T::Sig
+          ANNOTATIONS = {
+            abstract!: Annotation.new(arity: 0),
+            absurd: Annotation.new(arity: 1, receiver: true),
+            all: Annotation.new(arity: (2..), receiver: true),
+            any: Annotation.new(arity: (2..), receiver: true),
+            assert_type!: Annotation.new(arity: 2, receiver: true),
+            attached_class: Annotation.new(arity: 0, receiver: true),
+            bind: Annotation.new(arity: 2, receiver: true),
+            cast: Annotation.new(arity: 2, receiver: true),
+            class_of: Annotation.new(arity: 1, receiver: true),
+            enums: Annotation.new(arity: 0),
+            interface!: Annotation.new(arity: 0),
+            let: Annotation.new(arity: 2, receiver: true),
+            mixes_in_class_methods: Annotation.new(arity: 1),
+            must: Annotation.new(arity: 1, receiver: true),
+            must_because: Annotation.new(arity: 1, receiver: true),
+            nilable: Annotation.new(arity: 1, receiver: true),
+            noreturn: Annotation.new(arity: 0, receiver: true),
+            requires_ancestor: Annotation.new(arity: 0),
+            reveal_type: Annotation.new(arity: 1, receiver: true),
+            sealed!: Annotation.new(arity: 0),
+            self_type: Annotation.new(arity: 0, receiver: true),
+            sig: Annotation.new(arity: 0),
+            type_member: Annotation.new(arity: (0..1)),
+            type_template: Annotation.new(arity: 0),
+            unsafe: Annotation.new(arity: 1),
+            untyped: Annotation.new(arity: 0, receiver: true),
+          } #: Hash[Symbol, Annotation]
 
-          ANNOTATIONS = T.let(
-            {
-              abstract!: Annotation.new(arity: 0),
-              absurd: Annotation.new(arity: 1, receiver: true),
-              all: Annotation.new(arity: (2..), receiver: true),
-              any: Annotation.new(arity: (2..), receiver: true),
-              assert_type!: Annotation.new(arity: 2, receiver: true),
-              attached_class: Annotation.new(arity: 0, receiver: true),
-              bind: Annotation.new(arity: 2, receiver: true),
-              cast: Annotation.new(arity: 2, receiver: true),
-              class_of: Annotation.new(arity: 1, receiver: true),
-              enums: Annotation.new(arity: 0),
-              interface!: Annotation.new(arity: 0),
-              let: Annotation.new(arity: 2, receiver: true),
-              mixes_in_class_methods: Annotation.new(arity: 1),
-              must: Annotation.new(arity: 1, receiver: true),
-              must_because: Annotation.new(arity: 1, receiver: true),
-              nilable: Annotation.new(arity: 1, receiver: true),
-              noreturn: Annotation.new(arity: 0, receiver: true),
-              requires_ancestor: Annotation.new(arity: 0),
-              reveal_type: Annotation.new(arity: 1, receiver: true),
-              sealed!: Annotation.new(arity: 0),
-              self_type: Annotation.new(arity: 0, receiver: true),
-              sig: Annotation.new(arity: 0),
-              type_member: Annotation.new(arity: (0..1)),
-              type_template: Annotation.new(arity: 0),
-              unsafe: Annotation.new(arity: 1),
-              untyped: Annotation.new(arity: 0, receiver: true),
-            },
-            T::Hash[Symbol, Annotation],
-          )
-
-          sig do
-            params(
-              node: Prism::CallNode,
-            ).returns(T::Boolean)
-          end
+          #: (Prism::CallNode node) -> bool
           def annotation?(node)
             !!ANNOTATIONS[node.name]&.match?(node)
           end

data/lib/ruby_lsp/requests/support/source_uri.rb

@@ -6,43 +6,31 @@ require "uri/file"
 module URI
   # Must be kept in sync with the one in Tapioca
   class Source < URI::File
-    extend T::Sig
-
-    COMPONENT = T.let(
-      [
-        :scheme,
-        :gem_name,
-        :gem_version,
-        :path,
-        :line_number,
-      ].freeze,
-      T::Array[Symbol],
-    )
+    COMPONENT = [
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze #: Array[Symbol]
 
     # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
     # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
     # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
     # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
     # have the uri gem in their own bundle and thus not use a compatible version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
-    T.unsafe(self).alias_method(:gem_name, :host)
-    T.unsafe(self).alias_method(:line_number, :fragment)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:gem_name, :host)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:line_number, :fragment)
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :gem_version
 
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          gem_name: String,
-          gem_version: T.nilable(String),
-          path: String,
-          line_number: T.nilable(String),
-        ).returns(URI::Source)
-      end
+      #: (gem_name: String, gem_version: String?, path: String, line_number: String?) -> URI::Source
       def build(gem_name:, gem_version:, path:, line_number:)
         super(
           {
@@ -55,17 +43,17 @@ module URI
       end
     end
 
-    sig { params(v: T.nilable(String)).void }
+    #: (String? v) -> void
     def set_path(v) # rubocop:disable Naming/AccessorMethodName
       return if v.nil?
 
       gem_version, path = v.delete_prefix("/").split("/", 2)
 
-      @gem_version = T.let(gem_version, T.nilable(String))
-      @path = T.let(path, T.nilable(String))
+      @gem_version = gem_version #: String?
+      @path = path #: String?
     end
 
-    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    #: (String? v) -> bool
     def check_host(v)
       return true unless v
 
@@ -77,7 +65,7 @@ module URI
       true
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
     end
@@ -85,7 +73,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, T.untyped]) # rubocop:disable Style/ClassVars
+      @@schemes = @@schemes #: Hash[String, untyped] # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end