rbs 1.0.0 → 1.0.1

data/lib/rbs/parser.y

@@ -611,7 +611,7 @@ rule
       }
 
   type_decl:
-      annotations kTYPE qualified_name kEQ type {
+      annotations kTYPE type_alias_name kEQ type {
         location = val[1].location + val[4].location
         result = Declarations::Alias.new(name: val[2].value,
                                          type: val[4],
@@ -1037,6 +1037,16 @@ rule
         result = LocatedValue.new(value: type_name, location: location)
       }
 
+  type_alias_name:
+      namespace tLIDENT {
+        namespace = val[0]&.value || Namespace.empty
+        name = val[1].value.to_sym
+        type_name = TypeName.new(namespace: namespace, name: name)
+        location = (loc0 = val[0]&.location) ? loc0 + val[1].location : val[1].location
+        result = LocatedValue.new(value: type_name, location: location)
+      }
+
+
   namespace:
       {
         result = nil
@@ -1361,7 +1371,7 @@ def next_token
     new_token(:tWRITE_ATTR)
   when input.scan(KEYWORDS_RE)
     new_token(KEYWORDS[input.matched], input.matched.to_sym)
-  when input.scan(/:((@{,2}|\$)?\w+(\?|\!)?|\+|\-)\b?/)
+  when input.scan(/:((@{,2}|\$)?\w+(\?|\!)?|[|&\/%~`^]|<=>|={2,3}|=~|[<>]{2}|[<>]=?|[-+]@?|\*{1,2}|\[\]=?|![=~]?)\b?/)
     s = input.matched.yield_self {|s| s[1, s.length] }.to_sym
     new_token(:tSYMBOL, s)
   when input.scan(/[+-]?\d[\d_]*/)

data/lib/rbs/prototype/rb.rb

@@ -380,7 +380,7 @@ module RBS
       def function_type_from_body(node)
         table_node, args_node, *_ = node.children
 
-        pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_node.children
+        pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_from_node(args_node)
 
         return_type = function_return_type_from_body(node)
 
@@ -400,7 +400,8 @@ module RBS
         end
 
         if rest
-          fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest, type: untyped))
+          rest_name = rest == :* ? nil : rest # # For `def f(...) end` syntax
+          fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest_name, type: untyped))
         end
 
         table_node.drop(fun.required_positionals.size + fun.optional_positionals.size + (fun.rest_positionals ? 1 : 0)).take(post_num).each do |name|
@@ -559,13 +560,16 @@ module RBS
       def block_from_body(node)
         _, args_node, body_node = node.children
 
-        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_node.children
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
 
         method_block = nil
 
         if block
           method_block = Types::Block.new(
-            required: true,
+            # HACK: The `block` is :& on `def m(...)` syntax.
+            #       In this case the block looks optional in most cases, so it marks optional.
+            #       In other cases, we can't determine which is required or optional, so it marks required.
+            required: block != :&,
             type: Types::Function.empty(untyped)
           )
         end
@@ -614,6 +618,12 @@ module RBS
         method_block
       end
 
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
+      end
+
       def keyword_hash?(node)
         if node
           if node.type == :HASH

data/lib/rbs/test/setup_helper.rb

@@ -38,7 +38,6 @@ module RBS
           nil
         end
       end
-
     end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/rbs.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.6"
 end

data/sig/definition_builder.rbs

@@ -5,7 +5,7 @@ module RBS
     attr_reader ancestor_builder: AncestorBuilder
     attr_reader method_builder: MethodBuilder
 
-    attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader instance_cache: Hash[[TypeName, bool], Definition | false | nil]
     attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
     attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
     attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
@@ -18,7 +18,7 @@ module RBS
 
     def build_interface: (TypeName) -> Definition
 
-    def build_instance: (TypeName) -> Definition
+    def build_instance: (TypeName, ?no_self_types: bool) -> Definition
 
     def build_singleton0: (TypeName) -> Definition
 
@@ -31,6 +31,7 @@ module RBS
     def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> void
 
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
+                 | [A] (TypeName, cache: Hash[A, Definition | false | nil], key: A) { () -> Definition } -> Definition
 
     def validate_params_with: (AST::Declarations::ModuleTypeParams, result: VarianceCalculator::Result) { (AST::Declarations::ModuleTypeParams::TypeParam) -> void } -> void
 

data/stdlib/fileutils/0/fileutils.rbs

@@ -0,0 +1,585 @@
+# # fileutils.rb
+#
+# Copyright (c) 2000-2007 Minero Aoki
+#
+# This program is free software. You can distribute/modify this program under
+# the same terms of ruby.
+#
+# ## module FileUtils
+#
+# Namespace for several file utility methods for copying, moving, removing, etc.
+#
+# ### Module Functions
+#
+#     require 'fileutils'
+#
+#     FileUtils.cd(dir, **options)
+#     FileUtils.cd(dir, **options) {|dir| block }
+#     FileUtils.pwd()
+#     FileUtils.mkdir(dir, **options)
+#     FileUtils.mkdir(list, **options)
+#     FileUtils.mkdir_p(dir, **options)
+#     FileUtils.mkdir_p(list, **options)
+#     FileUtils.rmdir(dir, **options)
+#     FileUtils.rmdir(list, **options)
+#     FileUtils.ln(target, link, **options)
+#     FileUtils.ln(targets, dir, **options)
+#     FileUtils.ln_s(target, link, **options)
+#     FileUtils.ln_s(targets, dir, **options)
+#     FileUtils.ln_sf(target, link, **options)
+#     FileUtils.cp(src, dest, **options)
+#     FileUtils.cp(list, dir, **options)
+#     FileUtils.cp_r(src, dest, **options)
+#     FileUtils.cp_r(list, dir, **options)
+#     FileUtils.mv(src, dest, **options)
+#     FileUtils.mv(list, dir, **options)
+#     FileUtils.rm(list, **options)
+#     FileUtils.rm_r(list, **options)
+#     FileUtils.rm_rf(list, **options)
+#     FileUtils.install(src, dest, **options)
+#     FileUtils.chmod(mode, list, **options)
+#     FileUtils.chmod_R(mode, list, **options)
+#     FileUtils.chown(user, group, list, **options)
+#     FileUtils.chown_R(user, group, list, **options)
+#     FileUtils.touch(list, **options)
+#
+# Possible `options` are:
+#
+# `:force`
+# :   forced operation (rewrite files if exist, remove directories if not empty,
+#     etc.);
+# `:verbose`
+# :   print command to be run, in bash syntax, before performing it;
+# `:preserve`
+# :   preserve object's group, user and modification time on copying;
+# `:noop`
+# :   no changes are made (usable in combination with `:verbose` which will
+#     print the command to run)
+#
+#
+# Each method documents the options that it honours. See also ::commands,
+# ::options and ::options_of methods to introspect which command have which
+# options.
+#
+# All methods that have the concept of a "source" file or directory can take
+# either one file or a list of files in that argument.  See the method
+# documentation for examples.
+#
+# There are some `low level' methods, which do not accept keyword arguments:
+#
+#     FileUtils.copy_entry(src, dest, preserve = false, dereference_root = false, remove_destination = false)
+#     FileUtils.copy_file(src, dest, preserve = false, dereference = true)
+#     FileUtils.copy_stream(srcstream, deststream)
+#     FileUtils.remove_entry(path, force = false)
+#     FileUtils.remove_entry_secure(path, force = false)
+#     FileUtils.remove_file(path, force = false)
+#     FileUtils.compare_file(path_a, path_b)
+#     FileUtils.compare_stream(stream_a, stream_b)
+#     FileUtils.uptodate?(file, cmp_list)
+#
+# ## module FileUtils::Verbose
+#
+# This module has all methods of FileUtils module, but it outputs messages
+# before acting.  This equates to passing the `:verbose` flag to methods in
+# FileUtils.
+#
+# ## module FileUtils::NoWrite
+#
+# This module has all methods of FileUtils module, but never changes
+# files/directories.  This equates to passing the `:noop` flag to methods in
+# FileUtils.
+#
+# ## module FileUtils::DryRun
+#
+# This module has all methods of FileUtils module, but never changes
+# files/directories.  This equates to passing the `:noop` and `:verbose` flags
+# to methods in FileUtils.
+#
+module FileUtils
+  VERSION: String
+
+  type mode = Integer | String
+
+  type path = string | _ToPath
+
+  type pathlist = path | Array[path]
+
+  # Changes the current directory to the directory `dir`.
+  #
+  # If this method is called with block, resumes to the previous working directory
+  # after the block execution has finished.
+  #
+  #     FileUtils.cd('/')  # change directory
+  #
+  #     FileUtils.cd('/', verbose: true)   # change directory and report it
+  #
+  #     FileUtils.cd('/') do  # change directory
+  #       # ...               # do something
+  #     end                   # return to original directory
+  #
+  def self?.cd: (path dir, ?verbose: boolish) -> void
+              | [X] (path dir, ?verbose: boolish) { (String) -> X } -> X
+
+  alias self.chdir self.cd
+  alias chdir cd
+
+  # Changes permission bits on the named files (in `list`) to the bit pattern
+  # represented by `mode`.
+  #
+  # `mode` is the symbolic and absolute mode can be used.
+  #
+  # Absolute mode is
+  #     FileUtils.chmod 0755, 'somecommand'
+  #     FileUtils.chmod 0644, %w(my.rb your.rb his.rb her.rb)
+  #     FileUtils.chmod 0755, '/usr/bin/ruby', verbose: true
+  #
+  # Symbolic mode is
+  #     FileUtils.chmod "u=wrx,go=rx", 'somecommand'
+  #     FileUtils.chmod "u=wr,go=rr", %w(my.rb your.rb his.rb her.rb)
+  #     FileUtils.chmod "u=wrx,go=rx", '/usr/bin/ruby', verbose: true
+  #
+  # "a"
+  # :   is user, group, other mask.
+  # "u"
+  # :   is user's mask.
+  # "g"
+  # :   is group's mask.
+  # "o"
+  # :   is other's mask.
+  # "w"
+  # :   is write permission.
+  # "r"
+  # :   is read permission.
+  # "x"
+  # :   is execute permission.
+  # "X"
+  # :   is execute permission for directories only, must be used in conjunction
+  #     with "+"
+  # "s"
+  # :   is uid, gid.
+  # "t"
+  # :   is sticky bit.
+  # "+"
+  # :   is added to a class given the specified mode.
+  # "-"
+  # :   Is removed from a given class given mode.
+  # "="
+  # :   Is the exact nature of the class will be given a specified mode.
+  #
+  def self?.chmod: (mode mode, pathlist list, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Changes permission bits on the named files (in `list`) to the bit pattern
+  # represented by `mode`.
+  #
+  #     FileUtils.chmod_R 0700, "/tmp/app.#{$$}"
+  #     FileUtils.chmod_R "u=wrx", "/tmp/app.#{$$}"
+  #
+  def self?.chmod_R: (mode mode, pathlist list, ?noop: boolish, ?verbose: boolish, ?force: boolish) -> void
+
+  # Changes owner and group on the named files (in `list`) to the user `user` and
+  # the group `group`.  `user` and `group` may be an ID (Integer/String) or a name
+  # (String). If `user` or `group` is nil, this method does not change the
+  # attribute.
+  #
+  #     FileUtils.chown 'root', 'staff', '/usr/local/bin/ruby'
+  #     FileUtils.chown nil, 'bin', Dir.glob('/usr/bin/*'), verbose: true
+  #
+  def self?.chown: (String? user, String? group, pathlist list, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Changes owner and group on the named files (in `list`) to the user `user` and
+  # the group `group` recursively. `user` and `group` may be an ID
+  # (Integer/String) or a name (String).  If `user` or `group` is nil, this method
+  # does not change the attribute.
+  #
+  #     FileUtils.chown_R 'www', 'www', '/var/www/htdocs'
+  #     FileUtils.chown_R 'cvs', 'cvs', '/var/cvs', verbose: true
+  #
+  def self?.chown_R: (String? user, String? group, pathlist list, ?noop: boolish, ?verbose: boolish, ?force: boolish) -> void
+
+  # Returns an Array of methods names which have the option `opt`.
+  #
+  #     p FileUtils.collect_method(:preserve) #=> ["cp", "cp_r", "copy", "install"]
+  #
+  def self.collect_method: (Symbol opt) -> Array[String]
+
+  # Returns an Array of names of high-level methods that accept any keyword
+  # arguments.
+  #
+  #     p FileUtils.commands  #=> ["chmod", "cp", "cp_r", "install", ...]
+  #
+  def self.commands: () -> Array[String]
+
+  # Returns true if the contents of a file `a` and a file `b` are identical.
+  #
+  #     FileUtils.compare_file('somefile', 'somefile')       #=> true
+  #     FileUtils.compare_file('/dev/null', '/dev/urandom')  #=> false
+  #
+  def self?.compare_file: (path a, path b) -> bool
+
+  alias self.cmp self.compare_file
+  alias cmp compare_file
+
+  alias self.identical? self.compare_file
+  alias identical? compare_file
+
+  # Returns true if the contents of a stream `a` and `b` are identical.
+  #
+  def self?.compare_stream: (IO a, IO b) -> bool
+
+  # Copies a file system entry `src` to `dest`. If `src` is a directory, this
+  # method copies its contents recursively. This method preserves file types, c.f.
+  # symlink, directory... (FIFO, device files and etc. are not supported yet)
+  #
+  # Both of `src` and `dest` must be a path name. `src` must exist, `dest` must
+  # not exist.
+  #
+  # If `preserve` is true, this method preserves owner, group, and modified time.
+  # Permissions are copied regardless `preserve`.
+  #
+  # If `dereference_root` is true, this method dereference tree root.
+  #
+  # If `remove_destination` is true, this method removes each destination file
+  # before copy.
+  #
+  def self?.copy_entry: (path src, path dest, ?boolish preserve, ?boolish dereference_root, ?boolish remove_destination) -> void
+
+  # Copies file contents of `src` to `dest`. Both of `src` and `dest` must be a
+  # path name.
+  #
+  def self?.copy_file: (path src, path dest, ?boolish preserve, ?boolish dereference) -> void
+
+  # Copies stream `src` to `dest`. `src` must respond to #read(n) and `dest` must
+  # respond to #write(str).
+  #
+  def self?.copy_stream: (_Reader src, _Writer dest) -> void
+
+  # Copies a file content `src` to `dest`.  If `dest` is a directory, copies `src`
+  # to `dest/src`.
+  #
+  # If `src` is a list of files, then `dest` must be a directory.
+  #
+  #     FileUtils.cp 'eval.c', 'eval.c.org'
+  #     FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6'
+  #     FileUtils.cp %w(cgi.rb complex.rb date.rb), '/usr/lib/ruby/1.6', verbose: true
+  #     FileUtils.cp 'symlink', 'dest'   # copy content, "dest" is not a symlink
+  #
+  def self?.cp: (pathlist src, path dest, ?preserve: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.copy self.cp
+  alias copy cp
+
+  # Hard link `src` to `dest`. If `src` is a directory, this method links all its
+  # contents recursively. If `dest` is a directory, links `src` to `dest/src`.
+  #
+  # `src` can be a list of files.
+  #
+  # If `dereference_root` is true, this method dereference tree root.
+  #
+  # If `remove_destination` is true, this method removes each destination file
+  # before copy.
+  #
+  #     FileUtils.rm_r site_ruby + '/mylib', force: true
+  #     FileUtils.cp_lr 'lib/', site_ruby + '/mylib'
+  #
+  #     # Examples of linking several files to target directory.
+  #     FileUtils.cp_lr %w(mail.rb field.rb debug/), site_ruby + '/tmail'
+  #     FileUtils.cp_lr Dir.glob('*.rb'), '/home/aamine/lib/ruby', noop: true, verbose: true
+  #
+  #     # If you want to link all contents of a directory instead of the
+  #     # directory itself, c.f. src/x -> dest/x, src/y -> dest/y,
+  #     # use the following code.
+  #     FileUtils.cp_lr 'src/.', 'dest'  # cp_lr('src', 'dest') makes dest/src, but this doesn't.
+  #
+  def self?.cp_lr: (pathlist src, path dest, ?noop: boolish, ?verbose: boolish, ?dereference_root: boolish, ?remove_destination: boolish) -> void
+
+  # Copies `src` to `dest`. If `src` is a directory, this method copies all its
+  # contents recursively. If `dest` is a directory, copies `src` to `dest/src`.
+  #
+  # `src` can be a list of files.
+  #
+  # If `dereference_root` is true, this method dereference tree root.
+  #
+  # If `remove_destination` is true, this method removes each destination file
+  # before copy.
+  #
+  #     # Installing Ruby library "mylib" under the site_ruby
+  #     FileUtils.rm_r site_ruby + '/mylib', force: true
+  #     FileUtils.cp_r 'lib/', site_ruby + '/mylib'
+  #
+  #     # Examples of copying several files to target directory.
+  #     FileUtils.cp_r %w(mail.rb field.rb debug/), site_ruby + '/tmail'
+  #     FileUtils.cp_r Dir.glob('*.rb'), '/home/foo/lib/ruby', noop: true, verbose: true
+  #
+  #     # If you want to copy all contents of a directory instead of the
+  #     # directory itself, c.f. src/x -> dest/x, src/y -> dest/y,
+  #     # use following code.
+  #     FileUtils.cp_r 'src/.', 'dest'     # cp_r('src', 'dest') makes dest/src,
+  #                                        # but this doesn't.
+  #
+  def self?.cp_r: (pathlist src, path dest, ?preserve: boolish, ?noop: boolish, ?verbose: boolish, ?dereference_root: boolish, ?remove_destination: boolish) -> void
+
+  # Returns true if the method `mid` have an option `opt`.
+  #
+  #     p FileUtils.have_option?(:cp, :noop)     #=> true
+  #     p FileUtils.have_option?(:rm, :force)    #=> true
+  #     p FileUtils.have_option?(:rm, :preserve) #=> false
+  #
+  def self.have_option?: (Symbol mid, Symbol opt) -> bool
+
+  # If `src` is not same as `dest`, copies it and changes the permission mode to
+  # `mode`.  If `dest` is a directory, destination is `dest`/`src`. This method
+  # removes destination before copy.
+  #
+  #     FileUtils.install 'ruby', '/usr/local/bin/ruby', mode: 0755, verbose: true
+  #     FileUtils.install 'lib.rb', '/usr/local/lib/ruby/site_ruby', verbose: true
+  #
+  def self?.install: (path src, path dest, ?mode: mode?, ?owner: String?, ?group: String?, ?preserve: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Hard links a file system entry `src` to `dest`. If `src` is a directory, this
+  # method links its contents recursively.
+  #
+  # Both of `src` and `dest` must be a path name. `src` must exist, `dest` must
+  # not exist.
+  #
+  # If `dereference_root` is true, this method dereferences the tree root.
+  #
+  # If `remove_destination` is true, this method removes each destination file
+  # before copy.
+  #
+  def self?.link_entry: (path src, path dest, ?boolish dereference_root, ?boolish remove_destination) -> void
+
+  # In the first form, creates a hard link `link` which points to `target`. If
+  # `link` already exists, raises Errno::EEXIST. But if the `force` option is set,
+  # overwrites `link`.
+  #
+  #     FileUtils.ln 'gcc', 'cc', verbose: true
+  #     FileUtils.ln '/usr/bin/emacs21', '/usr/bin/emacs'
+  #
+  # In the second form, creates a link `dir/target` pointing to `target`. In the
+  # third form, creates several hard links in the directory `dir`, pointing to
+  # each item in `targets`. If `dir` is not a directory, raises Errno::ENOTDIR.
+  #
+  #     FileUtils.cd '/sbin'
+  #     FileUtils.ln %w(cp mv mkdir), '/bin'   # Now /sbin/cp and /bin/cp are linked.
+  #
+  def self?.ln: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.link self.ln
+  alias link ln
+
+  # In the first form, creates a symbolic link `link` which points to `target`. If
+  # `link` already exists, raises Errno::EEXIST. But if the `force` option is set,
+  # overwrites `link`.
+  #
+  #     FileUtils.ln_s '/usr/bin/ruby', '/usr/local/bin/ruby'
+  #     FileUtils.ln_s 'verylongsourcefilename.c', 'c', force: true
+  #
+  # In the second form, creates a link `dir/target` pointing to `target`. In the
+  # third form, creates several symbolic links in the directory `dir`, pointing to
+  # each item in `targets`. If `dir` is not a directory, raises Errno::ENOTDIR.
+  #
+  #     FileUtils.ln_s Dir.glob('/bin/*.rb'), '/home/foo/bin'
+  #
+  def self?.ln_s: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.symlink self.ln_s
+  alias symlink ln_s
+
+  # Same as
+  #
+  #     FileUtils.ln_s(*args, force: true)
+  #
+  def self?.ln_sf: (pathlist src, path dest, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Creates one or more directories.
+  #
+  #     FileUtils.mkdir 'test'
+  #     FileUtils.mkdir %w(tmp data)
+  #     FileUtils.mkdir 'notexist', noop: true  # Does not really create.
+  #     FileUtils.mkdir 'tmp', mode: 0700
+  #
+  def self?.mkdir: (pathlist list, ?mode: Integer?, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Creates a directory and all its parent directories. For example,
+  #
+  #     FileUtils.mkdir_p '/usr/local/lib/ruby'
+  #
+  # causes to make following directories, if they do not exist.
+  #
+  # *   /usr
+  # *   /usr/local
+  # *   /usr/local/lib
+  # *   /usr/local/lib/ruby
+  #
+  #
+  # You can pass several directories at a time in a list.
+  #
+  def self?.mkdir_p: (pathlist list, ?mode: mode?, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.makedirs self.mkdir_p
+  alias makedirs mkdir_p
+
+  alias self.mkpath self.mkdir_p
+  alias mkpath mkdir_p
+
+  # Moves file(s) `src` to `dest`.  If `file` and `dest` exist on the different
+  # disk partition, the file is copied then the original file is removed.
+  #
+  #     FileUtils.mv 'badname.rb', 'goodname.rb'
+  #     FileUtils.mv 'stuff.rb', '/notexist/lib/ruby', force: true  # no error
+  #
+  #     FileUtils.mv %w(junk.txt dust.txt), '/home/foo/.trash/'
+  #     FileUtils.mv Dir.glob('test*.rb'), 'test', noop: true, verbose: true
+  #
+  def self?.mv: (pathlist src, path dest, ?force: boolish, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void
+
+  alias self.move self.mv
+  alias move mv
+
+  # Returns an Array of option names.
+  #
+  #     p FileUtils.options  #=> ["noop", "force", "verbose", "preserve", "mode"]
+  #
+  def self.options: () -> Array[String]
+
+  # Returns an Array of option names of the method `mid`.
+  #
+  #     p FileUtils.options_of(:rm)  #=> ["noop", "verbose", "force"]
+  #
+  def self.options_of: (Symbol mid) -> Array[String]
+
+  # Returns the name of the current directory.
+  #
+  def self?.pwd: () -> String
+
+  alias self.getwd self.pwd
+  alias getwd pwd
+
+  # Removes a directory `dir` and its contents recursively. This method ignores
+  # StandardError if `force` is true.
+  #
+  def self?.remove_dir: (path path, ?boolish force) -> void
+
+  # This method removes a file system entry `path`. `path` might be a regular
+  # file, a directory, or something. If `path` is a directory, remove it
+  # recursively.
+  #
+  # See also remove_entry_secure.
+  #
+  def self?.remove_entry: (path path, ?boolish force) -> void
+
+  # This method removes a file system entry `path`.  `path` shall be a regular
+  # file, a directory, or something.  If `path` is a directory, remove it
+  # recursively.  This method is required to avoid TOCTTOU
+  # (time-of-check-to-time-of-use) local security vulnerability of rm_r. #rm_r
+  # causes security hole when:
+  #
+  # *   Parent directory is world writable (including /tmp).
+  # *   Removing directory tree includes world writable directory.
+  # *   The system has symbolic link.
+  #
+  #
+  # To avoid this security hole, this method applies special preprocess. If `path`
+  # is a directory, this method chown(2) and chmod(2) all removing directories.
+  # This requires the current process is the owner of the removing whole directory
+  # tree, or is the super user (root).
+  #
+  # WARNING: You must ensure that **ALL** parent directories cannot be moved by
+  # other untrusted users.  For example, parent directories should not be owned by
+  # untrusted users, and should not be world writable except when the sticky bit
+  # set.
+  #
+  # WARNING: Only the owner of the removing directory tree, or Unix super user
+  # (root) should invoke this method.  Otherwise this method does not work.
+  #
+  # For details of this security vulnerability, see Perl's case:
+  #
+  # *   https://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2005-0448
+  # *   https://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2004-0452
+  #
+  #
+  # For fileutils.rb, this vulnerability is reported in [ruby-dev:26100].
+  #
+  def self?.remove_entry_secure: (path path, ?boolish force) -> void
+
+  # Removes a file `path`. This method ignores StandardError if `force` is true.
+  #
+  def self?.remove_file: (path path, ?void force) -> void
+
+  # Remove file(s) specified in `list`.  This method cannot remove directories.
+  # All StandardErrors are ignored when the :force option is set.
+  #
+  #     FileUtils.rm %w( junk.txt dust.txt )
+  #     FileUtils.rm Dir.glob('*.so')
+  #     FileUtils.rm 'NotExistFile', force: true   # never raises exception
+  #
+  def self?.rm: (pathlist list, ?force: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.remove self.rm
+  alias remove rm
+
+  # Equivalent to
+  #
+  #     FileUtils.rm(list, force: true)
+  #
+  def self?.rm_f: (pathlist list, ?noop: boolish, ?verbose: boolish) -> void
+
+  alias self.safe_unlink self.rm_f
+  alias safe_unlink rm_f
+
+  # remove files `list[0]` `list[1]`... If `list[n]` is a directory, removes its
+  # all contents recursively. This method ignores StandardError when :force option
+  # is set.
+  #
+  #     FileUtils.rm_r Dir.glob('/tmp/*')
+  #     FileUtils.rm_r 'some_dir', force: true
+  #
+  # WARNING: This method causes local vulnerability if one of parent directories
+  # or removing directory tree are world writable (including /tmp, whose
+  # permission is 1777), and the current process has strong privilege such as Unix
+  # super user (root), and the system has symbolic link.  For secure removing,
+  # read the documentation of remove_entry_secure carefully, and set :secure
+  # option to true. Default is `secure: false`.
+  #
+  # NOTE: This method calls remove_entry_secure if :secure option is set. See also
+  # remove_entry_secure.
+  #
+  def self?.rm_r: (pathlist list, ?force: boolish, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void
+
+  # Equivalent to
+  #
+  #     FileUtils.rm_r(list, force: true)
+  #
+  # WARNING: This method causes local vulnerability. Read the documentation of
+  # rm_r first.
+  #
+  def self?.rm_rf: (pathlist list, ?noop: boolish, ?verbose: boolish, ?secure: boolish) -> void
+
+  alias self.rmtree self.rm_rf
+  alias rmtree rm_rf
+
+  # Removes one or more directories.
+  #
+  #     FileUtils.rmdir 'somedir'
+  #     FileUtils.rmdir %w(somedir anydir otherdir)
+  #     # Does not really remove directory; outputs message.
+  #     FileUtils.rmdir 'somedir', verbose: true, noop: true
+  #
+  def self?.rmdir: (pathlist list, ?parents: boolish, ?noop: boolish, ?verbose: boolish) -> void
+
+  # Updates modification time (mtime) and access time (atime) of file(s) in
+  # `list`.  Files are created if they don't exist.
+  #
+  #     FileUtils.touch 'timestamp'
+  #     FileUtils.touch Dir.glob('*.c');  system 'make'
+  #
+  def self?.touch: (pathlist list, ?noop: boolish, ?verbose: boolish, ?mtime: (Time | Numeric)?, ?nocreate: boolish) -> void
+
+  # Returns true if `new` is newer than all `old_list`. Non-existent files are
+  # older than any file.
+  #
+  #     FileUtils.uptodate?('hello.o', %w(hello.c hello.h)) or \
+  #         system 'make hello.o'
+  #
+  def self?.uptodate?: (path new, pathlist old_list) -> bool
+end