cli-kit 5.1.0 → 5.2.0

data/lib/cli/kit/opts.rb

@@ -5,16 +5,11 @@ require 'cli/kit'
 module CLI
   module Kit
     class Opts
-      extend T::Sig
-
       module Mixin
-        extend T::Sig
         include Kernel
 
         module MixinClassMethods
-          extend T::Sig
-
-          sig { params(included_module: Module).void }
+          #: (Module included_module) -> void
           def include(included_module)
             super
             return unless included_module.is_a?(MixinClassMethods)
@@ -28,36 +23,26 @@ module CLI
             track_method(method_name)
           end
 
-          sig { params(method_name: Symbol).void }
+          #: (Symbol method_name) -> void
           def track_method(method_name)
             @tracked_methods ||= []
             @tracked_methods << method_name unless @tracked_methods.include?(method_name)
           end
 
-          sig { returns(T::Array[Symbol]) }
+          #: -> Array[Symbol]
           def tracked_methods
             @tracked_methods || []
           end
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(klass: Module).void }
+          #: (Module klass) -> void
           def included(klass)
             klass.extend(MixinClassMethods)
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-          ).returns(T.nilable(String))
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String?
         def option(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
           unless default.nil?
             raise(ArgumentError, 'declare options with non-nil defaults using `option!` instead of `option`')
@@ -74,15 +59,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-          ).returns(String)
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String
         def option!(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
           case @obj
           when Args::Definition
@@ -95,15 +72,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(T::Array[String], T.proc.returns(T::Array[String])),
-          ).returns(T::Array[String])
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (Array[String] | ^-> Array[String])) -> Array[String]
         def multi_option(name: infer_name, short: nil, long: nil, desc: nil, default: [])
           case @obj
           when Args::Definition
@@ -116,14 +85,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-          ).returns(T::Boolean)
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?) -> bool
         def flag(name: infer_name, short: nil, long: nil, desc: nil)
           case @obj
           when Args::Definition
@@ -134,7 +96,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol, desc: T.nilable(String)).returns(String) }
+        #: (?name: Symbol, ?desc: String?) -> String
         def position!(name: infer_name, desc: nil)
           case @obj
           when Args::Definition
@@ -145,18 +107,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-            skip: T.any(
-              NilClass,
-              T.proc.returns(T::Boolean),
-              T.proc.params(arg0: String).returns(T::Boolean),
-            ),
-          ).returns(T.nilable(String))
-        end
+        #: (?name: Symbol, ?desc: String?, ?default: (String | ^-> String)?, ?skip: (^-> bool | ^(String arg0) -> bool)?) -> String?
         def position(name: infer_name, desc: nil, default: nil, skip: nil)
           case @obj
           when Args::Definition
@@ -167,7 +118,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol, desc: T.nilable(String)).returns(T::Array[String]) }
+        #: (?name: Symbol, ?desc: String?) -> Array[String]
         def rest(name: infer_name, desc: nil)
           case @obj
           when Args::Definition
@@ -180,14 +131,14 @@ module CLI
 
         private
 
-        sig { params(label: T.nilable(String)).returns(T.nilable(Symbol)) }
+        #: (String? label) -> Symbol?
         def symbolize(label)
           return if label.nil?
 
           label.split('#').last&.to_sym
         end
 
-        sig { returns(Symbol) }
+        #: -> Symbol
         def infer_name
           to_skip = 1
           Kernel.caller_locations.each do |loc|
@@ -197,7 +148,7 @@ module CLI
               to_skip -= 1
               next
             end
-            return T.must(symbolize(loc.label))
+            return symbolize(loc.label) #: as !nil
           end
           raise(ArgumentError, 'could not infer name')
         end
@@ -206,24 +157,18 @@ module CLI
 
       DEFAULT_OPTIONS = [:helpflag]
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def helpflag
         flag(name: :help, short: '-h', long: '--help', desc: 'Show this help message')
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def unparsed
         obj = assert_result!
         obj.unparsed
       end
 
-      sig do
-        params(
-          block: T.nilable(
-            T.proc.params(arg0: Symbol, arg1: T.nilable(String)).void,
-          ),
-        ).returns(T.untyped)
-      end
+      #: ?{ (Symbol arg0, String? arg1) -> void } -> untyped
       def each_option(&block)
         return enum_for(:each_option) unless block_given?
 
@@ -235,13 +180,7 @@ module CLI
         end
       end
 
-      sig do
-        params(
-          block: T.nilable(
-            T.proc.params(arg0: Symbol, arg1: T::Boolean).void,
-          ),
-        ).returns(T.untyped)
-      end
+      #: ?{ (Symbol arg0, bool arg1) -> void } -> untyped
       def each_flag(&block)
         return enum_for(:each_flag) unless block_given?
 
@@ -253,7 +192,7 @@ module CLI
         end
       end
 
-      sig { params(name: String).returns(T.nilable(T.any(String, T::Boolean))) }
+      #: (String name) -> (String | bool)?
       def [](name)
         obj = assert_result!
         if obj.opt.respond_to?(name)
@@ -263,7 +202,7 @@ module CLI
         end
       end
 
-      sig { params(name: String).returns(T.nilable(String)) }
+      #: (String name) -> String?
       def lookup_option(name)
         obj = assert_result!
         obj.opt.send(name)
@@ -272,7 +211,7 @@ module CLI
         nil
       end
 
-      sig { params(name: String).returns(T::Boolean) }
+      #: (String name) -> bool
       def lookup_flag(name)
         obj = assert_result!
         obj.flag.send(name)
@@ -280,17 +219,18 @@ module CLI
         false
       end
 
-      sig { returns(Args::Evaluation) }
+      #: -> Args::Evaluation
       def assert_result!
         raise(NotImplementedError, 'not implemented') if @obj.is_a?(Args::Definition)
 
         @obj
       end
 
-      sig { params(defn: Args::Definition).void }
+      #: (Args::Definition defn) -> void
       def define!(defn)
         @obj = defn
-        T.cast(self.class, Mixin::MixinClassMethods).tracked_methods.each do |m|
+        klass = self.class #: as Mixin::MixinClassMethods
+        klass.tracked_methods.each do |m|
           send(m)
         end
         DEFAULT_OPTIONS.each do |m|
@@ -298,7 +238,7 @@ module CLI
         end
       end
 
-      sig { params(ev: Args::Evaluation).void }
+      #: (Args::Evaluation ev) -> void
       def evaluate!(ev)
         @obj = ev
         ev.resolve_positions!

data/lib/cli/kit/parse_args.rb

@@ -6,18 +6,12 @@ module CLI
       # because sorbet type-checking takes the pedantic route that module doesn't include Kernel, therefore
       # this is necessary (even tho it's ~probably fine~)
       include Kernel
-      extend T::Sig
 
-      # T.untyped is used in two places. The interpretation of dynamic values from the provided `opts`
+      # untyped is used in two places. The interpretation of dynamic values from the provided `opts`
       # and the resulting args[:opts] is pretty broad. There seems to be minimal value in expressing a
-      # tighter subset of T.untyped.
+      # tighter subset of untyped.
 
-      sig do
-        params(
-          args: T.any(Array, String),
-          opts_defn: T::Hash[Symbol, T::Array[T.untyped]],
-        ).returns(T::Hash[Symbol, T.untyped])
-      end
+      #: ((Array | String) args, Hash[Symbol, Array[untyped]] opts_defn) -> Hash[Symbol, untyped]
       def parse_args(args, opts_defn)
         start_opts, parser_config = opts_defn.reduce([{}, []]) do |(ini, pcfg), (n, cfg)|
           (vals, desc, short, klass) = cfg
@@ -38,7 +32,8 @@ module CLI
             long = "--#{n.to_s.tr("_", "-")}" + (mark.nil? ? '' : " #{mark}")
             opt_args = klass.nil? ? [short, long, desc] : [short, long, klass, desc]
 
-            T.unsafe(opt_p).on(*opt_args) do |v|
+            unsafe_opt_p = opt_p #: as untyped
+            unsafe_opt_p.on(*opt_args) do |v|
               acc_opts[n] = if acc_opts.key?(n)
                 Array(acc_opts[n]) + Array(v || def_val)
               else

data/lib/cli/kit/resolver.rb

@@ -5,15 +5,13 @@ require 'cli/kit'
 module CLI
   module Kit
     class Resolver
-      extend T::Sig
-
-      sig { params(tool_name: String, command_registry: CLI::Kit::CommandRegistry).void }
+      #: (tool_name: String, command_registry: CLI::Kit::CommandRegistry) -> void
       def initialize(tool_name:, command_registry:)
         @tool_name = tool_name
         @command_registry = command_registry
       end
 
-      sig { params(args: T::Array[String]).returns([T.class_of(CLI::Kit::BaseCommand), String, T::Array[String]]) }
+      #: (Array[String] args) -> [singleton(CLI::Kit::BaseCommand), String, Array[String]]
       def call(args)
         args = args.dup
         command_name = args.shift
@@ -30,7 +28,7 @@ module CLI
 
       private
 
-      sig { params(name: T.nilable(String)).void }
+      #: (String? name) -> void
       def command_not_found(name)
         CLI::UI::Frame.open('Command not found', color: :red, timing: false) do
           $stderr.puts(CLI::UI.fmt("{{command:#{@tool_name} #{name}}} was not found"))
@@ -59,7 +57,7 @@ module CLI
         end
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def commands_and_aliases
         @command_registry.command_names + @command_registry.aliases.keys
       end

data/lib/cli/kit/support/test_helper.rb

@@ -14,7 +14,8 @@ module CLI
           CLI::Kit::System.reset!
           # this is in minitest, but sorbet doesn't know that. probably we
           # could structure this better.
-          T.unsafe(self).assert(false, errors) if should_raise && !errors.nil?
+          uself = self #: as untyped
+          uself.assert(false, errors) if should_raise && !errors.nil?
           errors
         end
 
@@ -67,7 +68,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_system(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_system(*a, sudo: sudo, env: env, **kwargs)
                   else
                     FakeSuccess.new(expected_command[:success])
                   end
@@ -83,7 +85,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture2(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture2(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -102,7 +105,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture2e(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture2e(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -121,7 +125,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture3(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture3(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],

data/lib/cli/kit/system.rb

@@ -9,8 +9,6 @@ module CLI
     module System
       SUDO_PROMPT = CLI::UI.fmt('{{info:(sudo)}} Password: ')
       class << self
-        extend T::Sig
-
         # Ask for sudo access with a message explaning the need for it
         # Will make subsequent commands capable of running with sudo for a period of time
         #
@@ -20,7 +18,7 @@ module CLI
         # #### Usage
         # `ctx.sudo_reason("We need to do a thing")`
         #
-        sig { params(msg: String).void }
+        #: (String msg) -> void
         def sudo_reason(msg)
           # See if sudo has a cached password
           %x(env SUDO_ASKPASS=/usr/bin/false sudo -A true > /dev/null 2>&1)
@@ -48,16 +46,7 @@ module CLI
         # #### Usage
         # `out, stat = CLI::Kit::System.capture2('ls', 'a_folder')`
         #
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-          )
-            .returns([String, Process::Status])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) -> [String, Process::Status]
         def capture2(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture2)
         end
@@ -79,16 +68,7 @@ module CLI
         # #### Usage
         # `out_and_err, stat = CLI::Kit::System.capture2e('ls', 'a_folder')`
         #
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-          )
-            .returns([String, Process::Status])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) -> [String, Process::Status]
         def capture2e(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture2e)
         end
@@ -111,70 +91,22 @@ module CLI
         # #### Usage
         # `out, err, stat = CLI::Kit::System.capture3('ls', 'a_folder')`
         #
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-          )
-            .returns([String, String, Process::Status])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) -> [String, String, Process::Status]
         def capture3(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture3)
         end
 
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-            block: T.nilable(
-              T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter)
-                .returns([IO, IO, Process::Waiter]),
-            ),
-          )
-            .returns([IO, IO, Process::Waiter])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) ?{ (IO stdin, IO stdout, Process::Waiter wait_thr) -> [IO, IO, Process::Waiter] } -> [IO, IO, Process::Waiter]
         def popen2(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen2, &block)
         end
 
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-            block: T.nilable(
-              T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter)
-                .returns([IO, IO, Process::Waiter]),
-            ),
-          )
-            .returns([IO, IO, Process::Waiter])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) ?{ (IO stdin, IO stdout, Process::Waiter wait_thr) -> [IO, IO, Process::Waiter] } -> [IO, IO, Process::Waiter]
         def popen2e(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen2e, &block)
         end
 
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            kwargs: T.untyped,
-            block: T.nilable(
-              T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter)
-                .returns([IO, IO, IO, Process::Waiter]),
-            ),
-          )
-            .returns([IO, IO, IO, Process::Waiter])
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], **untyped kwargs) ?{ (IO stdin, IO stdout, IO stderr, Process::Waiter wait_thr) -> [IO, IO, IO, Process::Waiter] } -> [IO, IO, IO, Process::Waiter]
         def popen3(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
           delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen3, &block)
         end
@@ -194,18 +126,7 @@ module CLI
         # #### Usage
         # `stat = CLI::Kit::System.system('ls', 'a_folder')`
         #
-        sig do
-          params(
-            cmd: String,
-            args: String,
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            stdin: T.nilable(T.any(IO, String, Integer, Symbol)),
-            kwargs: T.untyped,
-            block: T.nilable(T.proc.params(out: String, err: String).void),
-          )
-            .returns(Process::Status)
-        end
+        #: (String cmd, *String args, ?sudo: (String | bool), ?env: Hash[String, String?], ?stdin: (IO | String | Integer | Symbol)?, **untyped kwargs) ?{ (String out, String err) -> void } -> Process::Status
         def system(cmd, *args, sudo: false, env: ENV.to_h, stdin: nil, **kwargs, &block)
           cmd, args = apply_sudo(cmd, args, sudo)
 
@@ -219,7 +140,8 @@ module CLI
             STDIN
           end
           cmd, args = resolve_path(cmd, args, env)
-          pid = T.unsafe(Process).spawn(env, cmd, *args, 0 => in_stream, :out => out_w, :err => err_w, **kwargs)
+          process = Process #: as untyped
+          pid = process.spawn(env, cmd, *args, 0 => in_stream, :out => out_w, :err => err_w, **kwargs)
           out_w.close
           err_w.close
 
@@ -260,15 +182,16 @@ module CLI
         # Split off trailing partial UTF-8 Characters. UTF-8 Multibyte characters start with a 11xxxxxx byte that tells
         # how many following bytes are part of this character, followed by some number of 10xxxxxx bytes.  This simple
         # algorithm will split off a whole trailing multi-byte character.
-        sig { params(data: String).returns([String, String]) }
+        #: (String data) -> [String, String]
         def split_partial_characters(data)
-          last_byte = T.must(data.getbyte(-1))
+          last_byte = data.getbyte(-1) #: as !nil
           return [data, ''] if (last_byte & 0b1000_0000).zero?
 
           # UTF-8 is up to 4 characters per rune, so we could never want to trim more than that, and we want to avoid
           # allocating an array for the whole of data with bytes
           min_bound = -[4, data.bytesize].min
-          final_bytes = T.must(data.byteslice(min_bound..-1)).bytes
+          fb = data.byteslice(min_bound..-1) #: as !nil
+          final_bytes = fb.bytes
           partial_character_sub_index = final_bytes.rindex { |byte| byte & 0b1100_0000 == 0b1100_0000 }
 
           # Bail out for non UTF-8
@@ -293,10 +216,13 @@ module CLI
 
           partial_character_index = min_bound + partial_character_sub_index
 
-          [T.must(data.byteslice(0...partial_character_index)), T.must(data.byteslice(partial_character_index..-1))]
+          [
+            data.byteslice(0...partial_character_index), #: as !nil
+            data.byteslice(partial_character_index..-1), #: as !nil
+          ]
         end
 
-        sig { returns(Symbol) }
+        #: -> Symbol
         def os
           return :mac if /darwin/.match(RUBY_PLATFORM)
           return :linux if /linux/.match(RUBY_PLATFORM)
@@ -305,7 +231,7 @@ module CLI
           raise "Could not determine OS from platform #{RUBY_PLATFORM}"
         end
 
-        sig { params(cmd: String, env: T::Hash[String, T.nilable(String)]).returns(T.nilable(String)) }
+        #: (String cmd, Hash[String, String?] env) -> String?
         def which(cmd, env)
           exts = os == :windows ? (env['PATHEXT'] || 'exe').split(';') : ['']
           (env['PATH'] || '').split(File::PATH_SEPARATOR).each do |path|
@@ -320,10 +246,7 @@ module CLI
 
         private
 
-        sig do
-          params(cmd: String, args: T::Array[String], sudo: T.any(T::Boolean, String))
-            .returns([String, T::Array[String]])
-        end
+        #: (String cmd, Array[String] args, (String | bool) sudo) -> [String, Array[String]]
         def apply_sudo(cmd, args, sudo)
           return [cmd, args] if !sudo || Process.uid.zero?
 
@@ -331,21 +254,12 @@ module CLI
           ['sudo', args.unshift('-E', '-S', '-p', SUDO_PROMPT, '--', cmd)]
         end
 
-        sig do
-          params(
-            cmd: String,
-            args: T::Array[String],
-            kwargs: T::Hash[Symbol, T.untyped],
-            sudo: T.any(T::Boolean, String),
-            env: T::Hash[String, T.nilable(String)],
-            method: Symbol,
-            block: T.untyped,
-          ).returns(T.untyped)
-        end
+        #: (String cmd, Array[String] args, Hash[Symbol, untyped] kwargs, ?sudo: (String | bool), ?env: Hash[String, String?], ?method: Symbol) ?{ (?) -> untyped } -> untyped
         def delegate_open3(cmd, args, kwargs, sudo: raise, env: raise, method: raise, &block)
           cmd, args = apply_sudo(cmd, args, sudo)
           cmd, args = resolve_path(cmd, args, env)
-          T.unsafe(Open3).send(method, env, cmd, *args, **kwargs, &block)
+          open3 = Open3 #: as untyped
+          open3.send(method, env, cmd, *args, **kwargs, &block)
         rescue Errno::EINTR
           raise(Errno::EINTR, "command interrupted: #{cmd} #{args.join(" ")}")
         end
@@ -359,10 +273,7 @@ module CLI
         # project.
         #
         # See https://github.com/Shopify/dev/pull/625 for more details.
-        sig do
-          params(cmd: String, args: T::Array[String], env: T::Hash[String, T.nilable(String)])
-            .returns([String, T::Array[String]])
-        end
+        #: (String cmd, Array[String] args, Hash[String, String?] env) -> [String, Array[String]]
         def resolve_path(cmd, args, env)
           # If only one argument was provided, make sure it's interpreted by a shell.
           if args.empty?