tapioca 0.16.11 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05e19aeab9d997df21ef0b042afe97b1fdcca0b7ce148ecb4f05b0d14b792294
-  data.tar.gz: '09a81f179ccc96606f97bfffe3b07a113315ace4adf5d312998f6caae674cd6e'
+  metadata.gz: aae584802448b64d85f5d3da609325b145bc698816d6564a09a45696aa338901
+  data.tar.gz: d2673e9edcb91ba6fd7253a7bbd1b83505a4f2bb79ecde5159327f8775187d33
 SHA512:
-  metadata.gz: ec69dd3c33275760ebd701d92335da1d0afd7da6e8908887ef3622a836fad09d3e1752f2dedab1efc20fb805065968cea6ec7980cc0abd4561318529a45a6559
-  data.tar.gz: 1258bd043e9edb53e08afcc78fecdcbc5cc228d0a069beb31c4b2c3ef818d894d16751e2aa24f8e1a6c0b7eb144cc7cb47aba1aa834fa86a6502dc1bd9577649
+  metadata.gz: c1bbcb3975a85609b72642c849489743d4ba784c6ac5c5d1fe5f698dbadec683d141c8e8b42e63bd537f5c5770571d9446a05d865d381619b21ffe16acea8a89
+  data.tar.gz: dc09f320a84af9eac62d79219cfa282c630b2b01b72ddf33971b7e235757a9e96249f7c98c34ba13679c2d1e2a7148bf6609418fb03bbd904b991a665dfe76e1

data/lib/ruby_lsp/tapioca/addon.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.24")
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.25")
 
 begin
   # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the
@@ -20,19 +20,20 @@ module RubyLsp
     class Addon < ::RubyLsp::Addon
       extend T::Sig
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
-        @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
-        @rails_runner_client = T.let(Rails::NullClient.new, RubyLsp::Rails::RunnerClient)
-        @index = T.let(nil, T.nilable(RubyIndexer::Index))
-        @file_checksums = T.let({}, T::Hash[String, String])
-        @lockfile_diff = T.let(nil, T.nilable(String))
-        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
+        @global_state = nil #: RubyLsp::GlobalState?
+        @rails_runner_client = Rails::NullClient.new #: RubyLsp::Rails::RunnerClient
+        @index = nil #: RubyIndexer::Index?
+        @file_checksums = {} #: Hash[String, String]
+        @lockfile_diff = nil #: String?
+        @outgoing_queue = nil #: Thread::Queue?
       end
 
-      sig { override.params(global_state: RubyLsp::GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (RubyLsp::GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         return unless @global_state.enabled_feature?(:tapiocaAddon)
@@ -67,28 +68,31 @@ module RubyLsp
         end
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Tapioca"
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
         "0.1.3"
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
         return unless @global_state&.enabled_feature?(:tapiocaAddon)
         return unless @rails_runner_client.connected?
 
-        has_route_change = T.let(false, T::Boolean)
-        has_fixtures_change = T.let(false, T::Boolean)
-        needs_compiler_reload = T.let(false, T::Boolean)
+        has_route_change = false #: bool
+        has_fixtures_change = false #: bool
+        needs_compiler_reload = false #: bool
 
         constants = changes.flat_map do |change|
           path = URI(change[:uri]).to_standardized_path
@@ -153,7 +157,7 @@ module RubyLsp
 
       private
 
-      sig { params(feature_name: String).void }
+      #: (String feature_name) -> void
       def send_usage_telemetry(feature_name)
         return unless @outgoing_queue && @global_state
 
@@ -172,7 +176,7 @@ module RubyLsp
         })
       end
 
-      sig { params(change: T::Hash[Symbol, T.untyped], path: String).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] change, String path) -> bool
       def file_updated?(change, path)
         case change[:type]
         when Constant::FileChangeType::CREATED
@@ -201,7 +205,7 @@ module RubyLsp
         false
       end
 
-      sig { void }
+      #: -> void
       def run_gem_rbi_check
         gem_rbi_check = RunGemRbiCheck.new(T.must(@global_state).workspace_path)
         gem_rbi_check.run

data/lib/ruby_lsp/tapioca/run_gem_rbi_check.rb

@@ -13,15 +13,15 @@ module RubyLsp
       attr_reader :stderr
       attr_reader :status
 
-      sig { params(project_path: String).void }
+      #: (String project_path) -> void
       def initialize(project_path)
         @project_path = project_path
-        @stdout = T.let("", String)
-        @stderr = T.let("", String)
-        @status = T.let(nil, T.nilable(Process::Status))
+        @stdout = "" #: String
+        @stderr = "" #: String
+        @status = nil #: Process::Status?
       end
 
-      sig { void }
+      #: -> void
       def run
         return log_message("Not a git repository") unless git_repo?
 
@@ -36,35 +36,35 @@ module RubyLsp
 
       attr_reader :project_path
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def git_repo?
         _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: project_path)
         status.success?
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def lockfile_changed?
         !lockfile_diff.empty?
       end
 
-      sig { returns(Pathname) }
+      #: -> Pathname
       def lockfile
-        @lockfile ||= T.let(Pathname(project_path).join("Gemfile.lock"), T.nilable(Pathname))
+        @lockfile ||= Pathname(project_path).join("Gemfile.lock") #: Pathname?
       end
 
-      sig { returns(String) }
+      #: -> String
       def lockfile_diff
-        @lockfile_diff ||= T.let(read_lockfile_diff, T.nilable(String))
+        @lockfile_diff ||= read_lockfile_diff #: String?
       end
 
-      sig { returns(String) }
+      #: -> String
       def read_lockfile_diff
         return "" unless lockfile.exist?
 
         execute_in_project_path("git", "diff", lockfile.to_s).strip
       end
 
-      sig { void }
+      #: -> void
       def generate_gem_rbis
         parser = Tapioca::LockfileDiffParser.new(@lockfile_diff)
         removed_gems = parser.removed_gems
@@ -78,7 +78,7 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def execute_tapioca_gem_command(gems)
         Bundler.with_unbundled_env do
           stdout, stderr, status = T.unsafe(Open3).capture3(
@@ -97,7 +97,7 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def remove_rbis(gems)
         files = Dir.glob(
           "sorbet/rbi/gems/{#{gems.join(",")}}@*.rbi",
@@ -106,7 +106,7 @@ module RubyLsp
         delete_files(files, "Removed RBIs for")
       end
 
-      sig { void }
+      #: -> void
       def cleanup_orphaned_rbis
         untracked_files = git_ls_gem_rbis("--others", "--exclude-standard")
         deleted_files = git_ls_gem_rbis("--deleted")
@@ -115,7 +115,7 @@ module RubyLsp
         restore_files(deleted_files, "Restored deleted RBIs")
       end
 
-      sig { params(flags: T.untyped).returns(T::Array[String]) }
+      #: (*untyped flags) -> Array[String]
       def git_ls_gem_rbis(*flags)
         flags = T.unsafe(["git", "ls-files", *flags, "sorbet/rbi/gems/"])
 
@@ -124,20 +124,20 @@ module RubyLsp
           .map(&:strip)
       end
 
-      sig { params(files: T::Array[String], message: String).void }
+      #: (Array[String] files, String message) -> void
       def delete_files(files, message)
         files_to_remove = files.map { |file| File.join(project_path, file) }
         FileUtils.rm(files_to_remove)
         log_message("#{message}: #{files.join(", ")}") unless files.empty?
       end
 
-      sig { params(files: T::Array[String], message: String).void }
+      #: (Array[String] files, String message) -> void
       def restore_files(files, message)
         execute_in_project_path("git", "checkout", "--pathspec-from-file=-", stdin: files.join("\n"))
         log_message("#{message}: #{files.join(", ")}") unless files.empty?
       end
 
-      sig { params(message: String).void }
+      #: (String message) -> void
       def log_message(message)
         @stdout += "#{message}\n"
       end

data/lib/tapioca/bundler_ext/auto_require_hook.rb

@@ -12,13 +12,13 @@ module Tapioca
 
       requires_ancestor { ::Bundler::Dependency }
 
-      @exclude = T.let([], T::Array[String])
-      @enabled = T.let(false, T::Boolean)
+      @exclude = [] #: Array[String]
+      @enabled = false #: bool
 
       class << self
         extend T::Sig
 
-        sig { params(name: T.untyped).returns(T::Boolean) }
+        #: (untyped name) -> bool
         def excluded?(name)
           @exclude.include?(name)
         end
@@ -27,12 +27,7 @@ module Tapioca
           @enabled
         end
 
-        sig do
-          type_parameters(:Result).params(
-            exclude: T::Array[String],
-            blk: T.proc.returns(T.type_parameter(:Result)),
-          ).returns(T.type_parameter(:Result))
-        end
+        #: [Result] (exclude: Array[String]) { -> Result } -> Result
         def override_require_false(exclude:, &blk)
           @enabled = true
           @exclude = exclude
@@ -42,7 +37,7 @@ module Tapioca
         end
       end
 
-      sig { returns(T.untyped).checked(:never) }
+      #: -> untyped
       def autorequire
         value = super
 

data/lib/tapioca/commands/abstract_dsl.rb

@@ -9,28 +9,7 @@ module Tapioca
 
       abstract!
 
-      sig do
-        params(
-          requested_constants: T::Array[String],
-          requested_paths: T::Array[Pathname],
-          outpath: Pathname,
-          only: T::Array[String],
-          exclude: T::Array[String],
-          file_header: T::Boolean,
-          tapioca_path: String,
-          skip_constant: T::Array[String],
-          quiet: T::Boolean,
-          verbose: T::Boolean,
-          number_of_workers: T.nilable(Integer),
-          auto_strictness: T::Boolean,
-          gem_dir: String,
-          rbi_formatter: RBIFormatter,
-          app_root: String,
-          halt_upon_load_error: T::Boolean,
-          compiler_options: T::Hash[String, T.untyped],
-          lsp_addon: T::Boolean,
-        ).void
-      end
+      #: (requested_constants: Array[String], requested_paths: Array[Pathname], outpath: Pathname, only: Array[String], exclude: Array[String], file_header: bool, tapioca_path: String, ?skip_constant: Array[String], ?quiet: bool, ?verbose: bool, ?number_of_workers: Integer?, ?auto_strictness: bool, ?gem_dir: String, ?rbi_formatter: RBIFormatter, ?app_root: String, ?halt_upon_load_error: bool, ?compiler_options: Hash[String, untyped], ?lsp_addon: bool) -> void
       def initialize(
         requested_constants:,
         requested_paths:,
@@ -75,7 +54,7 @@ module Tapioca
 
       private
 
-      sig { params(outpath: Pathname, quiet: T::Boolean).returns(T::Set[Pathname]) }
+      #: (Pathname outpath, quiet: bool) -> Set[Pathname]
       def generate_dsl_rbi_files(outpath, quiet:)
         if @lsp_addon
           pipeline.active_compilers.each(&:reset_state)
@@ -103,20 +82,17 @@ module Tapioca
         files_to_purge
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def all_requested_constants
-        @all_requested_constants ||= T.let(
-          @requested_constants + constants_from_requested_paths,
-          T.nilable(T::Array[String]),
-        )
+        @all_requested_constants ||= @requested_constants + constants_from_requested_paths #: Array[String]?
       end
 
-      sig { returns(Tapioca::Dsl::Pipeline) }
+      #: -> Tapioca::Dsl::Pipeline
       def pipeline
-        @pipeline ||= T.let(create_pipeline, T.nilable(Tapioca::Dsl::Pipeline))
+        @pipeline ||= create_pipeline #: Tapioca::Dsl::Pipeline?
       end
 
-      sig { void }
+      #: -> void
       def load_application
         # Loaded ahead of time when using the add-on to avoid reloading multiple times
         return if @lsp_addon
@@ -129,7 +105,7 @@ module Tapioca
         )
       end
 
-      sig { returns(Tapioca::Dsl::Pipeline) }
+      #: -> Tapioca::Dsl::Pipeline
       def create_pipeline
         error_handler = if @lsp_addon
           ->(error) {
@@ -154,7 +130,7 @@ module Tapioca
         )
       end
 
-      sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+      #: (Array[String] requested_constants, ?path: Pathname) -> Set[Pathname]
       def existing_rbi_filenames(requested_constants, path: @outpath)
         filenames = if requested_constants.empty?
           Pathname.glob(path / "**/*.rbi")
@@ -168,7 +144,7 @@ module Tapioca
         filenames.to_set
       end
 
-      sig { params(constant_names: T::Array[String], ignore_missing: T::Boolean).returns(T::Array[Module]) }
+      #: (Array[String] constant_names, ?ignore_missing: bool) -> Array[Module]
       def constantize(constant_names, ignore_missing: false)
         constant_map = constant_names.to_h do |name|
           [name, Object.const_get(name)]
@@ -193,7 +169,7 @@ module Tapioca
           .grep(Module)
       end
 
-      sig { params(compiler_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+      #: (Array[String] compiler_names) -> Array[singleton(Tapioca::Dsl::Compiler)]
       def constantize_compilers(compiler_names)
         compiler_map = compiler_names.to_h do |name|
           [name, resolve(name)]
@@ -213,7 +189,7 @@ module Tapioca
         T.cast(compiler_map.values, T::Array[T.class_of(Tapioca::Dsl::Compiler)])
       end
 
-      sig { params(name: String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
+      #: (String name) -> singleton(Tapioca::Dsl::Compiler)?
       def resolve(name)
         # Try to find built-in tapioca compiler first, then globally defined compiler.
         potentials = Tapioca::Dsl::Compilers::NAMESPACES.map do |namespace|
@@ -226,14 +202,7 @@ module Tapioca
         potentials.compact.first
       end
 
-      sig do
-        params(
-          constant_name: String,
-          rbi: RBI::File,
-          outpath: Pathname,
-          quiet: T::Boolean,
-        ).returns(T.nilable(Pathname))
-      end
+      #: (String constant_name, RBI::File rbi, ?outpath: Pathname, ?quiet: bool) -> Pathname?
       def compile_dsl_rbi(constant_name, rbi, outpath: @outpath, quiet: false)
         return if rbi.empty?
 
@@ -251,7 +220,7 @@ module Tapioca
         filename
       end
 
-      sig { params(dir: Pathname).void }
+      #: (Pathname dir) -> void
       def perform_dsl_verification(dir)
         diff = verify_dsl_rbi(tmp_dir: dir)
 
@@ -260,7 +229,7 @@ module Tapioca
         FileUtils.remove_entry(dir)
       end
 
-      sig { params(files: T::Set[Pathname]).void }
+      #: (Set[Pathname] files) -> void
       def purge_stale_dsl_rbi_files(files)
         if files.any?
           say("Removing stale RBI files...")
@@ -272,12 +241,12 @@ module Tapioca
         end
       end
 
-      sig { params(constant_name: String).returns(Pathname) }
+      #: (String constant_name) -> Pathname
       def dsl_rbi_filename(constant_name)
         @outpath / "#{underscore(constant_name)}.rbi"
       end
 
-      sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+      #: (tmp_dir: Pathname) -> Hash[String, Symbol]
       def verify_dsl_rbi(tmp_dir:)
         diff = {}
 
@@ -309,7 +278,7 @@ module Tapioca
         diff
       end
 
-      sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+      #: (Symbol cause, Array[String] files) -> String
       def build_error_for_files(cause, files)
         filenames = files.map do |file|
           @outpath / file
@@ -318,7 +287,7 @@ module Tapioca
         "  File(s) #{cause}:\n  - #{filenames}"
       end
 
-      sig { params(diff: T::Hash[String, Symbol], command: Symbol).void }
+      #: (Hash[String, Symbol] diff, Symbol command) -> void
       def report_diff_and_exit_if_out_of_date(diff, command)
         if diff.empty?
           say("Nothing to do, all RBIs are up-to-date.")
@@ -340,14 +309,14 @@ module Tapioca
         end
       end
 
-      sig { params(path: Pathname).returns(T::Array[Pathname]) }
+      #: (Pathname path) -> Array[Pathname]
       def rbi_files_in(path)
         Pathname.glob(path / "**/*.rbi").map do |file|
           file.relative_path_from(path)
         end.sort
       end
 
-      sig { params(class_name: String).returns(String) }
+      #: (String class_name) -> String
       def underscore(class_name)
         return class_name unless /[A-Z-]|::/.match?(class_name)
 
@@ -359,22 +328,20 @@ module Tapioca
         word
       end
 
-      sig { params(constant: String).returns(String) }
+      #: (String constant) -> String
       def rbi_filename_for(constant)
         underscore(constant) + ".rbi"
       end
 
-      sig { params(constant: String).returns(String) }
+      #: (String constant) -> String
       def generate_command_for(constant)
         default_command(:dsl, constant)
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def constants_from_requested_paths
-        @constants_from_requested_paths ||= T.let(
-          Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a,
-          T.nilable(T::Array[String]),
-        )
+        @constants_from_requested_paths ||=
+          Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a #: Array[String]?
       end
     end
   end

data/lib/tapioca/commands/abstract_gem.rb

@@ -9,27 +9,7 @@ module Tapioca
 
       abstract!
 
-      sig do
-        params(
-          gem_names: T::Array[String],
-          exclude: T::Array[String],
-          include_dependencies: T::Boolean,
-          prerequire: T.nilable(String),
-          postrequire: String,
-          typed_overrides: T::Hash[String, String],
-          outpath: Pathname,
-          file_header: T::Boolean,
-          include_doc: T::Boolean,
-          include_loc: T::Boolean,
-          include_exported_rbis: T::Boolean,
-          number_of_workers: T.nilable(Integer),
-          auto_strictness: T::Boolean,
-          dsl_dir: String,
-          rbi_formatter: RBIFormatter,
-          halt_upon_load_error: T::Boolean,
-          lsp_addon: T.nilable(T::Boolean),
-        ).void
-      end
+      #: (gem_names: Array[String], exclude: Array[String], include_dependencies: bool, prerequire: String?, postrequire: String, typed_overrides: Hash[String, String], outpath: Pathname, file_header: bool, include_doc: bool, include_loc: bool, include_exported_rbis: bool, ?number_of_workers: Integer?, ?auto_strictness: bool, ?dsl_dir: String, ?rbi_formatter: RBIFormatter, ?halt_upon_load_error: bool, ?lsp_addon: bool?) -> void
       def initialize(
         gem_names:,
         exclude:,
@@ -65,18 +45,18 @@ module Tapioca
 
         super()
 
-        @bundle = T.let(Gemfile.new(exclude), Gemfile)
-        @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
-        @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
-        @include_doc = T.let(include_doc, T::Boolean)
-        @include_loc = T.let(include_loc, T::Boolean)
+        @bundle = Gemfile.new(exclude) #: Gemfile
+        @existing_rbis = nil #: Hash[String, String]?
+        @expected_rbis = nil #: Hash[String, String]?
+        @include_doc = include_doc #: bool
+        @include_loc = include_loc #: bool
         @include_exported_rbis = include_exported_rbis
         @halt_upon_load_error = halt_upon_load_error
       end
 
       private
 
-      sig { params(gem: Gemfile::GemSpec).void }
+      #: (Gemfile::GemSpec gem) -> void
       def compile_gem_rbi(gem)
         gem_name = set_color(gem.name, :yellow, :bold)
 
@@ -116,12 +96,12 @@ module Tapioca
         end
       end
 
-      sig { void }
+      #: -> void
       def perform_removals
         say("Removing RBI files of gems that have been removed:", [:blue, :bold])
         puts
 
-        anything_done = T.let(false, T::Boolean)
+        anything_done = false #: bool
 
         gems = removed_rbis
 
@@ -143,12 +123,12 @@ module Tapioca
         anything_done
       end
 
-      sig { void }
+      #: -> void
       def perform_additions
         say("Generating RBI files of gems that are added or updated:", [:blue, :bold])
         puts
 
-        anything_done = T.let(false, T::Boolean)
+        anything_done = false #: bool
 
         gems = added_rbis
 
@@ -186,34 +166,34 @@ module Tapioca
         anything_done
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def removed_rbis
         (existing_rbis.keys - expected_rbis.keys).sort
       end
 
-      sig { params(gem_name: String).returns(Pathname) }
+      #: (String gem_name) -> Pathname
       def existing_rbi(gem_name)
         gem_rbi_filename(gem_name, T.must(existing_rbis[gem_name]))
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def added_rbis
         expected_rbis.select do |name, value|
           existing_rbis[name] != value
         end.keys.sort
       end
 
-      sig { params(gem_name: String).returns(Pathname) }
+      #: (String gem_name) -> Pathname
       def expected_rbi(gem_name)
         gem_rbi_filename(gem_name, T.must(expected_rbis[gem_name]))
       end
 
-      sig { params(gem_name: String).returns(T::Boolean) }
+      #: (String gem_name) -> bool
       def gem_rbi_exists?(gem_name)
         existing_rbis.key?(gem_name)
       end
 
-      sig { params(diff: T::Hash[String, Symbol], command: Symbol).void }
+      #: (Hash[String, Symbol] diff, Symbol command) -> void
       def report_diff_and_exit_if_out_of_date(diff, command)
         if diff.empty?
           say("Nothing to do, all RBIs are up-to-date.")
@@ -233,36 +213,36 @@ module Tapioca
         end
       end
 
-      sig { params(old_filename: Pathname, new_filename: Pathname).void }
+      #: (Pathname old_filename, Pathname new_filename) -> void
       def move(old_filename, new_filename)
         say("-> Moving: #{old_filename} to #{new_filename}")
         old_filename.rename(new_filename.to_s)
       end
 
-      sig { returns(T::Hash[String, String]) }
+      #: -> Hash[String, String]
       def existing_rbis
         @existing_rbis ||= Pathname.glob((@outpath / "*@*.rbi").to_s)
           .to_h { |f| T.cast(f.basename(".*").to_s.split("@", 2), [String, String]) }
       end
 
-      sig { returns(T::Hash[String, String]) }
+      #: -> Hash[String, String]
       def expected_rbis
         @expected_rbis ||= @bundle.dependencies
           .reject { |gem| @exclude.include?(gem.name) }
           .to_h { |gem| [gem.name, gem.version.to_s] }
       end
 
-      sig { params(gem_name: String, version: String).returns(Pathname) }
+      #: (String gem_name, String version) -> Pathname
       def gem_rbi_filename(gem_name, version)
         @outpath / "#{gem_name}@#{version}.rbi"
       end
 
-      sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+      #: (Symbol cause, Array[String] files) -> String
       def build_error_for_files(cause, files)
         "  File(s) #{cause}:\n  - #{files.join("\n  - ")}"
       end
 
-      sig { params(gem: Gemfile::GemSpec, file: RBI::File).void }
+      #: (Gemfile::GemSpec gem, RBI::File file) -> void
       def merge_with_exported_rbi(gem, file)
         return file unless gem.export_rbi_files?