cli-kit 5.1.0 → 5.3.0

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?

data/lib/cli/kit/util.rb

@@ -6,21 +6,17 @@ module CLI
   module Kit
     module Util
       class << self
-        extend T::Sig
         #
         # Converts an integer representing bytes into a human readable format
         #
-        sig { params(bytes: Integer, precision: Integer, space: T::Boolean).returns(String) }
+        #: (Integer bytes, ?precision: Integer, ?space: bool) -> String
         def to_filesize(bytes, precision: 2, space: false)
           to_si_scale(bytes, 'B', precision: precision, space: space, factor: 1024)
         end
 
         # Converts a number to a human readable format on the SI scale
         #
-        sig do
-          params(number: Numeric, unit: String, factor: Integer, precision: Integer, space: T::Boolean)
-            .returns(String)
-        end
+        #: (Numeric number, ?String unit, ?factor: Integer, ?precision: Integer, ?space: bool) -> String
         def to_si_scale(number, unit = '', factor: 1000, precision: 2, space: false)
           raise ArgumentError, 'factor should only be 1000 or 1024' unless [1000, 1024].include?(factor)
 
@@ -37,11 +33,11 @@ module CLI
             if number < 1
               index = [-scale - 1, small_scale.length].min
               scale = -(index + 1)
-              prefix = T.must(small_scale[index])
+              prefix = small_scale[index] #: as !nil
             else
               index = [scale - 1, big_scale.length].min
               scale = index + 1
-              prefix = T.must(big_scale[index])
+              prefix = big_scale[index] #: as !nil
             end
           end
 
@@ -62,10 +58,7 @@ module CLI
         # Dir.chdir, when invoked in block form, complains when we call chdir
         # again recursively. There's no apparent good reason for this, so we
         # simply implement our own block form of Dir.chdir here.
-        sig do
-          type_parameters(:T).params(dir: String, block: T.proc.returns(T.type_parameter(:T)))
-            .returns(T.type_parameter(:T))
-        end
+        #: [T] (String dir) { -> T } -> T
         def with_dir(dir, &block)
           prev = Dir.pwd
           begin
@@ -85,44 +78,35 @@ module CLI
         # end.retry_after(ExpectedError) do
         #   costly_prep()
         # end
-        sig do
-          type_parameters(:T).params(block_that_might_raise: T.proc.returns(T.type_parameter(:T)))
-            .returns(Retrier[T.type_parameter(:T)])
-        end
+        #: [T] { -> T } -> Retrier[T]
         def begin(&block_that_might_raise)
           Retrier.new(block_that_might_raise)
         end
       end
 
+      #: [BlockReturnType]
       class Retrier
-        extend T::Sig
-        extend T::Generic
-
-        BlockReturnType = type_member
-
-        sig { params(block_that_might_raise: T.proc.returns(BlockReturnType)).void }
+        #: (^-> BlockReturnType block_that_might_raise) -> void
         def initialize(block_that_might_raise)
           @block_that_might_raise = block_that_might_raise
         end
 
-        sig do
-          params(
-            exception: T.class_of(Exception),
-            retries: Integer,
-            before_retry: T.nilable(T.proc.params(e: Exception).void),
-          ).returns(BlockReturnType)
-        end
+        #: (?singleton(Exception) exception, ?retries: Integer) ?{ (Exception e) -> void } -> BlockReturnType
         def retry_after(exception = StandardError, retries: 1, &before_retry)
           @block_that_might_raise.call
         rescue exception => e
           raise if (retries -= 1) < 0
 
           if before_retry
+            # rubocop:disable Style/IdenticalConditionalBranches
             if before_retry.arity == 0
-              T.cast(before_retry, T.proc.void).call
+              prc = before_retry #: as ^() -> void
+              prc.call
             else
-              T.cast(before_retry, T.proc.params(e: Exception).void).call(e)
+              prc = before_retry #: as ^(Exception) -> void
+              prc.call(e)
             end
+            # rubocop:enable Style/IdenticalConditionalBranches
           end
           retry
         end

data/lib/cli/kit/version.rb

@@ -2,6 +2,6 @@
 
 module CLI
   module Kit
-    VERSION = '5.1.0'
+    VERSION = '5.3.0'
   end
 end

data/lib/cli/kit.rb

@@ -1,17 +1,10 @@
 # typed: true
 
 require 'cli/ui'
-
-unless defined?(T)
-  require('cli/kit/sorbet_runtime_stub')
-end
-
 require 'cli/kit/core_ext'
 
 module CLI
   module Kit
-    extend T::Sig
-
     autoload :Args,            'cli/kit/args'
     autoload :BaseCommand,     'cli/kit/base_command'
     autoload :CommandRegistry, 'cli/kit/command_registry'
@@ -33,6 +26,9 @@ module CLI
     EXIT_BUG                 = 1
     EXIT_SUCCESS             = 0
 
+    UNTYPED_NIL = nil #: untyped
+    private_constant(:UNTYPED_NIL)
+
     # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
     # on command-line execution when an unrecoverable error occurs.
     #
@@ -76,9 +72,7 @@ module CLI
     GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
 
     class Abort < GenericAbort # bug:false; silent: false
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def bug?
         false
       end
@@ -88,31 +82,25 @@ module CLI
     end
 
     class BugSilent < GenericAbort # bug:true; silent:true
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def silent?
         true
       end
     end
 
     class AbortSilent < GenericAbort # bug:false; silent:true
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def bug?
         false
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def silent?
         true
       end
     end
 
     class << self
-      extend T::Sig
-
       # Mirrors the API of Kernel#raise, but with the addition of a few new
       # optional keyword arguments. `bug` and `silent` attach metadata to the
       # exception being raised, which is interpreted later in the ErrorHandler to
@@ -121,35 +109,30 @@ module CLI
       # `depth` is used to trim leading elements of the backtrace. If you wrap
       # this method in your own wrapper, you'll want to pass `depth: 2`, for
       # example.
-      sig do
-        params(
-          exception: T.any(Class, String, Exception),
-          string: T.untyped,
-          array: T.nilable(T::Array[String]),
-          cause: T.nilable(Exception),
-          bug: T.nilable(T::Boolean),
-          silent: T.nilable(T::Boolean),
-          depth: Integer,
-        ).returns(T.noreturn)
-      end
+      #: (?(Class | String | Exception) exception, ?untyped string, ?Array[String]? array, ?cause: Exception?, ?bug: bool?, ?silent: bool?, ?fault: Exception::Fault?, ?depth: Integer) -> bot
       def raise(
         # default arguments
-        exception = T.unsafe(nil), string = T.unsafe(nil), array = T.unsafe(nil), cause: $ERROR_INFO,
+        exception = UNTYPED_NIL,
+        string = UNTYPED_NIL,
+        array = UNTYPED_NIL,
+        cause: $ERROR_INFO,
         # new arguments
-        bug: nil, silent: nil, depth: 1
+        bug: nil, silent: nil, fault: nil, depth: 1
       )
+        k = Kernel #: as untyped
         if array
-          T.unsafe(Kernel).raise(exception, string, array, cause: cause)
+          k.raise(exception, string, array, cause: cause)
         elsif string
-          T.unsafe(Kernel).raise(exception, string, Kernel.caller(depth), cause: cause)
+          k.raise(exception, string, Kernel.caller(depth), cause: cause)
         elsif exception.is_a?(String)
-          T.unsafe(Kernel).raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
+          k.raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
         else
-          T.unsafe(Kernel).raise(exception, exception.message, Kernel.caller(depth), cause: cause)
+          k.raise(exception, exception.message, Kernel.caller(depth), cause: cause)
         end
       rescue Exception => e # rubocop:disable Lint/RescueException
         e.bug!(bug) unless bug.nil?
         e.silent!(silent) unless silent.nil?
+        e.fault!(fault) if fault
         Kernel.raise(e, cause: cause)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cli-kit
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.3.0
 platform: ruby
 authors:
 - Burke Libbey
@@ -26,6 +26,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +95,9 @@ extra_rdoc_files: []
 files:
 - ".github/CODEOWNERS"
 - ".github/dependabot.yml"
+- ".github/release.yml"
 - ".github/workflows/cla.yml"
+- ".github/workflows/release.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.sorbet.yml"
@@ -148,7 +164,6 @@ files:
 - lib/cli/kit/opts.rb
 - lib/cli/kit/parse_args.rb
 - lib/cli/kit/resolver.rb
-- lib/cli/kit/sorbet_runtime_stub.rb
 - lib/cli/kit/support.rb
 - lib/cli/kit/support/test_helper.rb
 - lib/cli/kit/system.rb
@@ -165,7 +180,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/cli/kit/sorbet_runtime_stub.rb

@@ -1,154 +0,0 @@
-# typed: ignore
-# frozen_string_literal: true
-
-module T
-  class << self
-    def absurd(value); end
-    def all(type_a, type_b, *types); end
-    def any(type_a, type_b, *types); end
-    def attached_class; end
-    def class_of(klass); end
-    def enum(values); end
-    def nilable(type); end
-    def noreturn; end
-    def self_type; end
-    def type_alias(type = nil, &_blk); end
-    def type_parameter(name); end
-    def untyped; end
-
-    def assert_type!(value, _type, _checked: true)
-      value
-    end
-
-    def cast(value, _type, _checked: true)
-      value
-    end
-
-    def let(value, _type, _checked: true)
-      value
-    end
-
-    def must(arg, _msg = nil)
-      arg
-    end
-
-    def proc
-      T::Proc.new
-    end
-
-    def reveal_type(value)
-      value
-    end
-
-    def unsafe(value)
-      value
-    end
-  end
-
-  module Sig
-    def sig(arg0 = nil, &blk); end
-  end
-
-  module Helpers
-    def abstract!; end
-    def interface!; end
-    def final!; end
-    def sealed!; end
-    def mixes_in_class_methods(mod); end
-  end
-
-  module Generic
-    include(T::Helpers)
-
-    def type_parameters(*params); end
-    def type_member(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
-    def type_template(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
-
-    def [](*types)
-      self
-    end
-  end
-
-  module Array
-    class << self
-      def [](type); end
-    end
-  end
-
-  Boolean = Object.new.freeze
-
-  module Configuration
-    class << self
-      def call_validation_error_handler(signature, opts); end
-      def call_validation_error_handler=(value); end
-      def default_checked_level=(default_checked_level); end
-      def enable_checking_for_sigs_marked_checked_tests; end
-      def enable_final_checks_on_hooks; end
-      def enable_legacy_t_enum_migration_mode; end
-      def reset_final_checks_on_hooks; end
-      def hard_assert_handler(str, extra); end
-      def hard_assert_handler=(value); end
-      def inline_type_error_handler(error); end
-      def inline_type_error_handler=(value); end
-      def log_info_handler(str, extra); end
-      def log_info_handler=(value); end
-      def scalar_types; end
-      def scalar_types=(values); end
-      def sealed_violation_whitelist; end
-      def sealed_violation_whitelist=(sealed_violation_whitelist); end
-      def sig_builder_error_handler=(value); end
-      def sig_validation_error_handler(error, opts); end
-      def sig_validation_error_handler=(value); end
-      def soft_assert_handler(str, extra); end
-      def soft_assert_handler=(value); end
-    end
-  end
-
-  module Enumerable
-    class << self
-      def [](type); end
-    end
-  end
-
-  module Enumerator
-    class << self
-      def [](type); end
-    end
-  end
-
-  module Hash
-    class << self
-      def [](keys, values); end
-    end
-  end
-
-  class Proc
-    def bind(*_)
-      self
-    end
-
-    def params(*_param)
-      self
-    end
-
-    def void
-      self
-    end
-
-    def returns(_type)
-      self
-    end
-  end
-
-  module Range
-    class << self
-      def [](type); end
-    end
-  end
-
-  module Set
-    class << self
-      def [](type); end
-    end
-  end
-end