rbs 1.4.0 → 1.6.1

data/stdlib/objspace/0/objspace.rbs

@@ -0,0 +1,406 @@
+# The objspace library extends the ObjectSpace module and adds several methods
+# to get internal statistic information about object/memory management.
+#
+# You need to `require 'objspace'` to use this extension module.
+#
+# Generally, you *SHOULD NOT* use this library if you do not know about the MRI
+# implementation.  Mainly, this library is for (memory) profiler developers and
+# MRI developers who need to know about MRI memory usage.
+# The ObjectSpace module contains a number of routines that interact with the
+# garbage collection facility and allow you to traverse all living objects with
+# an iterator.
+#
+# ObjectSpace also provides support for object finalizers, procs that will be
+# called when a specific object is about to be destroyed by garbage collection.
+# See the documentation for `ObjectSpace.define_finalizer` for important
+# information on how to use this method correctly.
+#
+#     a = "A"
+#     b = "B"
+#
+#     ObjectSpace.define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
+#     ObjectSpace.define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
+#
+#     a = nil
+#     b = nil
+#
+# *produces:*
+#
+#     Finalizer two on 537763470
+#     Finalizer one on 537763480
+module ObjectSpace
+  # Returns the class for the given `object`.
+  #
+  #     class A
+  #       def foo
+  #         ObjectSpace::trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{ObjectSpace::allocation_class_path(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     A.new.foo #=> "Class"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_class_path: (untyped) -> String
+
+  # Returns garbage collector generation for the given `object`.
+  #
+  #     class B
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "Generation is #{allocation_generation(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     B.new.foo #=> "Generation is 3"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_generation: (untyped) -> (Integer | nil)
+
+  # Returns the method identifier for the given `object`.
+  #
+  #     class A
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{allocation_class_path(obj)}##{allocation_method_id(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     A.new.foo #=> "Class#new"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_method_id: (untyped) -> Symbol
+
+  # Returns the source file origin from the given `object`.
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_sourcefile: (untyped) -> String
+
+  # Returns the original line from source for from the given `object`.
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_sourceline: (untyped) -> Integer
+
+  # Counts objects for each `T_IMEMO` type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {:imemo_ifunc=>8,
+  #      :imemo_svar=>7,
+  #      :imemo_cref=>509,
+  #      :imemo_memo=>1,
+  #      :imemo_throw_data=>1}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation specific and may change in
+  # the future.
+  #
+  # In this version, keys are symbol objects.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_imemo_objects: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts nodes for each node type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {:NODE_METHOD=>2027, :NODE_FBODY=>1927, :NODE_CFUNC=>1798, ...}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # Note: The contents of the returned hash is implementation defined. It may be
+  # changed in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_nodes: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts objects size (in bytes) for each type.
+  #
+  # Note that this information is incomplete.  You need to deal with this
+  # information as only a **HINT**.  Especially, total size of T_DATA may be
+  # wrong.
+  #
+  # It returns a hash as:
+  #     {:TOTAL=>1461154, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249, ...}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation defined. It may be changed
+  # in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_objects_size: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts symbols for each Symbol type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # Note: The contents of the returned hash is implementation defined. It may be
+  # changed in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  # On this version of MRI, they have 3 types of Symbols (and 1 total counts).
+  #
+  #     * mortal_dynamic_symbol: GC target symbols (collected by GC)
+  #     * immortal_dynamic_symbol: Immortal symbols promoted from dynamic symbols (do not collected by GC)
+  #     * immortal_static_symbol: Immortal symbols (do not collected by GC)
+  #     * immortal_symbol: total immortal symbols (immortal_dynamic_symbol+immortal_static_symbol)
+  #
+  def self.count_symbols: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts objects for each `T_DATA` type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {RubyVM::InstructionSequence=>504, :parser=>5, :barrier=>6,
+  #      :mutex=>6, Proc=>60, RubyVM::Env=>57, Mutex=>1, Encoding=>99,
+  #      ThreadGroup=>1, Binding=>1, Thread=>1, RubyVM=>1, :iseq=>1,
+  #      Random=>1, ARGF.class=>1, Data=>1, :autoload=>3, Time=>2}
+  #     # T_DATA objects existing at startup on r32276.
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation specific and may change in
+  # the future.
+  #
+  # In this version, keys are Class object or Symbol object.
+  #
+  # If object is kind of normal (accessible) object, the key is Class object. If
+  # object is not a kind of normal (internal) object, the key is symbol name,
+  # registered by rb_data_type_struct.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_tdata_objects: (?Hash[untyped, Integer] result_hash) -> Hash[untyped, Integer]
+
+  def self.dump: (untyped obj, ?output: Symbol) -> (String | File | nil)
+
+  def self.dump_all: (?since: (Integer|nil), ?full: boolish, ?output: Symbol) -> (String | File | nil)
+
+  # MRI specific feature
+  # :   Return internal class of obj.
+  #
+  # obj can be an instance of InternalObjectWrapper.
+  #
+  # Note that you should not use this method in your application.
+  #
+  def self.internal_class_of: (untyped) -> Class
+
+  # MRI specific feature
+  # :   Return internal super class of cls (Class or Module).
+  #
+  # obj can be an instance of InternalObjectWrapper.
+  #
+  # Note that you should not use this method in your application.
+  #
+  def self.internal_super_of: (untyped) -> untyped
+
+  # Return consuming memory size of obj in bytes.
+  #
+  # Note that the return size is incomplete.  You need to deal with this
+  # information as only a **HINT**. Especially, the size of `T_DATA` may not be
+  # correct.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  # From Ruby 2.2, memsize_of(obj) returns a memory size includes sizeof(RVALUE).
+  #
+  def self.memsize_of: (untyped) -> Integer
+
+  # Return consuming memory size of all living objects in bytes.
+  #
+  # If `klass` (should be Class object) is given, return the total memory size of
+  # instances of the given class.
+  #
+  # Note that the returned size is incomplete. You need to deal with this
+  # information as only a **HINT**. Especially, the size of `T_DATA` may not be
+  # correct.
+  #
+  # Note that this method does **NOT** return total malloc'ed memory size.
+  #
+  # This method can be defined by the following Ruby code:
+  #
+  #     def memsize_of_all klass = false
+  #       total = 0
+  #       ObjectSpace.each_object{|e|
+  #         total += ObjectSpace.memsize_of(e) if klass == false || e.kind_of?(klass)
+  #       }
+  #       total
+  #     end
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.memsize_of_all: (?Class) -> Integer
+
+  # MRI specific feature
+  # :   Return all reachable objects from `obj'.
+  #
+  #
+  # This method returns all reachable objects from `obj'.
+  #
+  # If `obj' has two or more references to the same object `x', then returned
+  # array only includes one `x' object.
+  #
+  # If `obj' is a non-markable (non-heap management) object such as true, false,
+  # nil, symbols and Fixnums (and Flonum) then it simply returns nil.
+  #
+  # If `obj' has references to an internal object, then it returns instances of
+  # ObjectSpace::InternalObjectWrapper class. This object contains a reference to
+  # an internal object and you can check the type of internal object with `type'
+  # method.
+  #
+  # If `obj' is instance of ObjectSpace::InternalObjectWrapper class, then this
+  # method returns all reachable object from an internal object, which is pointed
+  # by `obj'.
+  #
+  # With this method, you can find memory leaks.
+  #
+  # This method is only expected to work except with C Ruby.
+  #
+  # Example:
+  #     ObjectSpace.reachable_objects_from(['a', 'b', 'c'])
+  #     #=> [Array, 'a', 'b', 'c']
+  #
+  #     ObjectSpace.reachable_objects_from(['a', 'a', 'a'])
+  #     #=> [Array, 'a', 'a', 'a'] # all 'a' strings have different object id
+  #
+  #     ObjectSpace.reachable_objects_from([v = 'a', v, v])
+  #     #=> [Array, 'a']
+  #
+  #     ObjectSpace.reachable_objects_from(1)
+  #     #=> nil # 1 is not markable (heap managed) object
+  #
+  def self.reachable_objects_from: (untyped) -> ([ untyped ] | nil)
+
+  # MRI specific feature
+  # :   Return all reachable objects from root.
+  #
+  #
+  def self.reachable_objects_from_root: () -> Hash[String, untyped]
+
+  # Starts tracing object allocations from the ObjectSpace extension module.
+  #
+  # For example:
+  #
+  #     require 'objspace'
+  #
+  #     class C
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     C.new.foo #=> "objtrace.rb:8"
+  #
+  # This example has included the ObjectSpace module to make it easier to read,
+  # but you can also use the ::trace_object_allocations notation (recommended).
+  #
+  # Note that this feature introduces a huge performance decrease and huge memory
+  # consumption.
+  #
+  def self.trace_object_allocations: () { (untyped) -> untyped } -> untyped
+
+  # Clear recorded tracing information.
+  #
+  def self.trace_object_allocations_clear: () -> void
+
+  def self.trace_object_allocations_debug_start: () -> void
+
+  # Starts tracing object allocations.
+  #
+  def self.trace_object_allocations_start: () -> void
+
+  # Stop tracing object allocations.
+  #
+  # Note that if ::trace_object_allocations_start is called n-times, then tracing
+  # will stop after calling ::trace_object_allocations_stop n-times.
+  #
+  def self.trace_object_allocations_stop: () -> void
+
+  private
+
+  # Dump the contents of a ruby object as JSON.
+  #
+  # This method is only expected to work with C Ruby. This is an experimental
+  # method and is subject to change. In particular, the function signature and
+  # output format are not guaranteed to be compatible in future versions of ruby.
+  #
+  def dump: (untyped obj, ?output: Symbol) -> (String|File|nil)
+
+  # Dump the contents of the ruby heap as JSON.
+  #
+  # *since* must be a non-negative integer or `nil`.
+  #
+  # If *since* is a positive integer, only objects of that generation and newer
+  # generations are dumped. The current generation can be accessed using
+  # GC::count.
+  #
+  # Objects that were allocated without object allocation tracing enabled are
+  # ignored. See ::trace_object_allocations for more information and examples.
+  #
+  # If *since* is omitted or is `nil`, all objects are dumped.
+  #
+  # This method is only expected to work with C Ruby. This is an experimental
+  # method and is subject to change. In particular, the function signature and
+  # output format are not guaranteed to be compatible in future versions of ruby.
+  #
+  def dump_all: (?since: (Integer|nil), ?full: boolish, ?output: Symbol) -> (String|File|nil)
+
+  def memsize_of: (untyped) -> Integer
+
+  def memsize_of_all: (?class) -> Integer
+
+  def reachable_objects_from: (untyped) -> ([ untyped ] | nil)
+
+  def reachable_objects_from_root: () -> Hash[String, untyped]
+
+  def trace_object_allocations_clear: () -> void
+
+  def trace_object_allocations_debug_start: () -> void
+
+  def trace_object_allocations_start: () -> void
+
+  def trace_object_allocations_stop: () -> void
+end

data/stdlib/openssl/0/openssl.rbs

@@ -2028,7 +2028,7 @@ module OpenSSL
 
       def check_key: () -> true
 
-      def dh_compute_key: (instance public_key) -> String
+      def dh_compute_key: (Point public_key) -> String
 
       def dsa_sign_asn1: (String digest) -> String
 

data/stdlib/tempfile/0/tempfile.rbs

@@ -0,0 +1,270 @@
+# A utility class for managing temporary files. When you create a Tempfile
+# object, it will create a temporary file with a unique filename. A Tempfile
+# objects behaves just like a File object, and you can perform all the usual
+# file operations on it: reading data, writing data, changing its permissions,
+# etc. So although this class does not explicitly document all instance methods
+# supported by File, you can in fact call any File instance method on a Tempfile
+# object.
+#
+# ## Synopsis
+#
+#     require 'tempfile'
+#
+#     file = Tempfile.new('foo')
+#     file.path      # => A unique filename in the OS's temp directory,
+#                    #    e.g.: "/tmp/foo.24722.0"
+#                    #    This filename contains 'foo' in its basename.
+#     file.write("hello world")
+#     file.rewind
+#     file.read      # => "hello world"
+#     file.close
+#     file.unlink    # deletes the temp file
+#
+# ## Good practices
+#
+# ### Explicit close
+#
+# When a Tempfile object is garbage collected, or when the Ruby interpreter
+# exits, its associated temporary file is automatically deleted. This means
+# that's it's unnecessary to explicitly delete a Tempfile after use, though it's
+# good practice to do so: not explicitly deleting unused Tempfiles can
+# potentially leave behind large amounts of tempfiles on the filesystem until
+# they're garbage collected. The existence of these temp files can make it
+# harder to determine a new Tempfile filename.
+#
+# Therefore, one should always call #unlink or close in an ensure block, like
+# this:
+#
+#     file = Tempfile.new('foo')
+#     begin
+#        # ...do something with file...
+#     ensure
+#        file.close
+#        file.unlink   # deletes the temp file
+#     end
+#
+# Tempfile.create { ... } exists for this purpose and is more convenient to use.
+# Note that Tempfile.create returns a File instance instead of a Tempfile, which
+# also avoids the overhead and complications of delegation.
+#
+#     Tempfile.open('foo') do |file|
+#        # ...do something with file...
+#     end
+#
+# ### Unlink after creation
+#
+# On POSIX systems, it's possible to unlink a file right after creating it, and
+# before closing it. This removes the filesystem entry without closing the file
+# handle, so it ensures that only the processes that already had the file handle
+# open can access the file's contents. It's strongly recommended that you do
+# this if you do not want any other processes to be able to read from or write
+# to the Tempfile, and you do not need to know the Tempfile's filename either.
+#
+# For example, a practical use case for unlink-after-creation would be this: you
+# need a large byte buffer that's too large to comfortably fit in RAM, e.g. when
+# you're writing a web server and you want to buffer the client's file upload
+# data.
+#
+# Please refer to #unlink for more information and a code example.
+#
+# ## Minor notes
+#
+# Tempfile's filename picking method is both thread-safe and inter-process-safe:
+# it guarantees that no other threads or processes will pick the same filename.
+#
+# Tempfile itself however may not be entirely thread-safe. If you access the
+# same Tempfile object from multiple threads then you should protect it with a
+# mutex.
+class Tempfile < File
+  # Creates a temporary file as a usual File object (not a Tempfile). It does not
+  # use finalizer and delegation, which makes it more efficient and reliable.
+  #
+  # If no block is given, this is similar to Tempfile.new except creating File
+  # instead of Tempfile. In that case, the created file is not removed
+  # automatically. You should use File.unlink to remove it.
+  #
+  # If a block is given, then a File object will be constructed, and the block is
+  # invoked with the object as the argument. The File object will be automatically
+  # closed and the temporary file is removed after the block terminates, releasing
+  # all resources that the block created. The call returns the value of the block.
+  #
+  # In any case, all arguments (`basename`, `tmpdir`, `mode`, and `**options`)
+  # will be treated the same as for Tempfile.new.
+  #
+  #     Tempfile.create('foo', '/home/temp') do |f|
+  #        # ... do something with f ...
+  #     end
+  #
+  def self.create: (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) -> File
+                 | [A] (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) { (File) -> A } -> A
+
+  # Creates a new Tempfile.
+  #
+  # This method is not recommended and exists mostly for backward compatibility.
+  # Please use Tempfile.create instead, which avoids the cost of delegation, does
+  # not rely on a finalizer, and also unlinks the file when given a block.
+  #
+  # Tempfile.open is still appropriate if you need the Tempfile to be unlinked by
+  # a finalizer and you cannot explicitly know where in the program the Tempfile
+  # can be unlinked safely.
+  #
+  # If no block is given, this is a synonym for Tempfile.new.
+  #
+  # If a block is given, then a Tempfile object will be constructed, and the block
+  # is run with the Tempfile object as argument. The Tempfile object will be
+  # automatically closed after the block terminates. However, the file will
+  # **not** be unlinked and needs to be manually unlinked with Tempfile#close! or
+  # Tempfile#unlink. The finalizer will try to unlink but should not be relied
+  # upon as it can keep the file on the disk much longer than intended. For
+  # instance, on CRuby, finalizers can be delayed due to conservative stack
+  # scanning and references left in unused memory.
+  #
+  # The call returns the value of the block.
+  #
+  # In any case, all arguments (`*args`) will be passed to Tempfile.new.
+  #
+  #     Tempfile.open('foo', '/home/temp') do |f|
+  #        # ... do something with f ...
+  #     end
+  #
+  #     # Equivalent:
+  #     f = Tempfile.open('foo', '/home/temp')
+  #     begin
+  #        # ... do something with f ...
+  #     ensure
+  #        f.close
+  #     end
+  #
+  def self.open: (*untyped args, **untyped) -> Tempfile
+               | [A] (*untyped args, **untyped) { (Tempfile) -> A } -> A
+
+  public
+
+  # Closes the file. If `unlink_now` is true, then the file will be unlinked
+  # (deleted) after closing. Of course, you can choose to later call #unlink if
+  # you do not unlink it now.
+  #
+  # If you don't explicitly unlink the temporary file, the removal will be delayed
+  # until the object is finalized.
+  #
+  def close: (?boolish unlink_now) -> void
+
+  # Closes and unlinks (deletes) the file. Has the same effect as called
+  # `close(true)`.
+  #
+  def close!: () -> void
+
+  alias delete unlink
+
+  def inspect: () -> String
+
+  alias length size
+
+  # Opens or reopens the file with mode "r+".
+  #
+  def open: () -> File
+
+  # Returns the full path name of the temporary file. This will be nil if #unlink
+  # has been called.
+  #
+  def path: () -> String?
+
+  # Returns the size of the temporary file.  As a side effect, the IO buffer is
+  # flushed before determining the size.
+  #
+  def size: () -> Integer
+
+  # Unlinks (deletes) the file from the filesystem. One should always unlink the
+  # file after using it, as is explained in the "Explicit close" good practice
+  # section in the Tempfile overview:
+  #
+  #     file = Tempfile.new('foo')
+  #     begin
+  #        # ...do something with file...
+  #     ensure
+  #        file.close
+  #        file.unlink   # deletes the temp file
+  #     end
+  #
+  # ### Unlink-before-close
+  #
+  # On POSIX systems it's possible to unlink a file before closing it. This
+  # practice is explained in detail in the Tempfile overview (section "Unlink
+  # after creation"); please refer there for more information.
+  #
+  # However, unlink-before-close may not be supported on non-POSIX operating
+  # systems. Microsoft Windows is the most notable case: unlinking a non-closed
+  # file will result in an error, which this method will silently ignore. If you
+  # want to practice unlink-before-close whenever possible, then you should write
+  # code like this:
+  #
+  #     file = Tempfile.new('foo')
+  #     file.unlink   # On Windows this silently fails.
+  #     begin
+  #        # ... do something with file ...
+  #     ensure
+  #        file.close!   # Closes the file handle. If the file wasn't unlinked
+  #                      # because #unlink failed, then this method will attempt
+  #                      # to do so again.
+  #     end
+  #
+  def unlink: () -> void
+
+  class Remover
+    public
+
+    def call: (*untyped args) -> void
+
+    private
+
+    def initialize: (::Tempfile tmpfile) -> void
+  end
+
+  private
+
+  # Creates a temporary file with permissions 0600 (= only readable and writable
+  # by the owner) and opens it with mode "w+".
+  #
+  # It is recommended to use Tempfile.create { ... } instead when possible,
+  # because that method avoids the cost of delegation and does not rely on a
+  # finalizer to close and unlink the file, which is unreliable.
+  #
+  # The `basename` parameter is used to determine the name of the temporary file.
+  # You can either pass a String or an Array with 2 String elements. In the former
+  # form, the temporary file's base name will begin with the given string. In the
+  # latter form, the temporary file's base name will begin with the array's first
+  # element, and end with the second element. For example:
+  #
+  #     file = Tempfile.new('hello')
+  #     file.path  # => something like: "/tmp/hello2843-8392-92849382--0"
+  #
+  #     # Use the Array form to enforce an extension in the filename:
+  #     file = Tempfile.new(['hello', '.jpg'])
+  #     file.path  # => something like: "/tmp/hello2843-8392-92849382--0.jpg"
+  #
+  # The temporary file will be placed in the directory as specified by the
+  # `tmpdir` parameter. By default, this is `Dir.tmpdir`.
+  #
+  #     file = Tempfile.new('hello', '/home/aisaka')
+  #     file.path  # => something like: "/home/aisaka/hello2843-8392-92849382--0"
+  #
+  # You can also pass an options hash. Under the hood, Tempfile creates the
+  # temporary file using `File.open`. These options will be passed to `File.open`.
+  # This is mostly useful for specifying encoding options, e.g.:
+  #
+  #     Tempfile.new('hello', '/home/aisaka', encoding: 'ascii-8bit')
+  #
+  #     # You can also omit the 'tmpdir' parameter:
+  #     Tempfile.new('hello', encoding: 'ascii-8bit')
+  #
+  # Note: `mode` keyword argument, as accepted by Tempfile, can only be numeric,
+  # combination of the modes defined in File::Constants.
+  #
+  # ### Exceptions
+  #
+  # If Tempfile.new cannot find a unique filename within a limited number of
+  # tries, then it will raise an exception.
+  #
+  def self.new: (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) -> instance
+              | [A] (?String basename, ?String? tmpdir, ?mode: Integer, **untyped) { (instance) -> A } -> A
+end