rbs 2.0.0 → 2.2.2

data/core/file.rbs

@@ -1,3 +1,4 @@
+# <!-- rdoc-file=file.c -->
 # A File is an abstraction of any file object accessible by the program and is
 # closely associated with class IO.  File includes the methods of module
 # FileTest as class methods, allowing you to write (for example)
@@ -25,7 +26,286 @@
 #
 # Various constants for the methods in File can be found in File::Constants.
 #
+# ## What's Here
+#
+# First, what's elsewhere. Class File:
+#
+# *   Inherits from [class IO](IO.html#class-IO-label-What-27s+Here), in
+#     particular, methods for creating, reading, and writing files
+# *   Includes [module
+#     FileTest](FileTest.html#module-FileTest-label-What-27s+Here). which
+#     provides dozens of additional methods.
+#
+#
+# Here, class File provides methods that are useful for:
+#
+# *   [Creating](#class-File-label-Creating)
+# *   [Querying](#class-File-label-Querying)
+# *   [Settings](#class-File-label-Settings)
+# *   [Other](#class-File-label-Other)
+#
+#
+# ### Creating
+#
+#     ::new
+# :       Opens the file at the given path; returns the file.
+#
+#     ::open
+# :       Same as ::new, but when given a block will yield the file to the
+#         block, and close the file upon exiting the block.
+#
+#     ::link
+# :       Creates a new name for an existing file using a hard link.
+#
+#     ::mkfifo
+# :       Returns the FIFO file created at the given path.
+#
+#     ::symlink
+# :       Creates a symbolic link for the given file path.
+#
+#
+#
+# ### Querying
+#
+# *Paths*
+#
+#     ::absolute_path
+# :       Returns the absolute file path for the given path.
+#
+#     ::absolute_path?
+# :       Returns whether the given path is the absolute file path.
+#
+#     ::basename
+# :       Returns the last component of the given file path.
+#
+#     ::dirname
+# :       Returns all but the last component of the given file path.
+#
+#     ::expand_path
+# :       Returns the absolute file path for the given path, expanding `~` for a
+#         home directory.
+#
+#     ::extname
+# :       Returns the file extension for the given file path.
+#
+#     ::fnmatch? (aliased as ::fnmatch)
+# :       Returns whether the given file path matches the given pattern.
+#
+#     ::join
+# :       Joins path components into a single path string.
+#
+#     ::path
+# :       Returns the string representation of the given path.
+#
+#     ::readlink
+# :       Returns the path to the file at the given symbolic link.
+#
+#     ::realdirpath
+# :       Returns the real path for the given file path, where the last
+#         component need not exist.
+#
+#     ::realpath
+# :       Returns the real path for the given file path, where all components
+#         must exist.
+#
+#     ::split
+# :       Returns an array of two strings: the directory name and basename of
+#         the file at the given path.
+#
+#     #path (aliased as #to_path)
+# :       Returns the string representation of the given path.
+#
+#
+#
+# *Times*
+#
+#     ::atime
+# :       Returns a Time for the most recent access to the given file.
+#
+#     ::birthtime
+# :       Returns a Time  for the creation of the given file.
+#
+#     ::ctime
+# :       Returns a Time  for the metadata change of the given file.
+#
+#     ::mtime
+# :       Returns a Time for the most recent data modification to the content of
+#         the given file.
+#
+#     #atime
+# :       Returns a Time for the most recent access to `self`.
+#
+#     #birthtime
+# :       Returns a Time  the creation for `self`.
+#
+#     #ctime
+# :       Returns a Time for the metadata change of `self`.
+#
+#     #mtime
+# :       Returns a Time for the most recent data modification to the content of
+#         `self`.
+#
+#
+#
+# *Types*
+#
+#     ::blockdev?
+# :       Returns whether the file at the given path is a block device.
+#
+#     ::chardev?
+# :       Returns whether the file at the given path is a character device.
+#
+#     ::directory?
+# :       Returns whether the file at the given path is a diretory.
+#
+#     ::executable?
+# :       Returns whether the file at the given path is executable by the
+#         effective user and group of the current process.
+#
+#     ::executable_real?
+# :       Returns whether the file at the given path is executable by the real
+#         user and group of the current process.
+#
+#     ::exist?
+# :       Returns whether the file at the given path exists.
+#
+#     ::file?
+# :       Returns whether the file at the given path is a regular file.
+#
+#     ::ftype
+# :       Returns a string giving the type of the file at the given path.
+#
+#     ::grpowned?
+# :       Returns whether the effective group of the current process owns the
+#         file at the given path.
+#
+#     ::identical?
+# :       Returns whether the files at two given paths are identical.
+#
+#     ::lstat
+# :       Returns the File::Stat object for the last symbolic link in the given
+#         path.
+#
+#     ::owned?
+# :       Returns whether the effective user of the current process owns the
+#         file at the given path.
+#
+#     ::pipe?
+# :       Returns whether the file at the given path is a pipe.
+#
+#     ::readable?
+# :       Returns whether the file at the given path is readable by the
+#         effective user and group of the current process.
+#
+#     ::readable_real?
+# :       Returns whether the file at the given path is readable by the real
+#         user and group of the current process.
+#
+#     ::setgid?
+# :       Returns whether the setgid bit is set for the file at the given path.
+#
+#     ::setuid?
+# :       Returns whether the setuid bit is set for the file at the given path.
+#
+#     ::socket?
+# :       Returns whether the file at the given path is a socket.
+#
+#     ::stat
+# :       Returns the File::Stat object for the file at the given path.
+#
+#     ::sticky?
+# :       Returns whether the file at the given path has its sticky bit set.
+#
+#     ::symlink?
+# :       Returns whether the file at the given path is a symbolic link.
+#
+#     ::umask
+# :       Returns the umask value for the current process.
+#
+#     ::world_readable?
+# :       Returns whether the file at the given path is readable by others.
+#
+#     ::world_writable?
+# :       Returns whether the file at the given path is writable by others.
+#
+#     ::writable?
+# :       Returns whether the file at the given path is writable by the
+#         effective user and group of the current process.
+#
+#     ::writable_real?
+# :       Returns whether the file at the given path is writable by the real
+#         user and group of the current process.
+#
+#     #lstat
+# :       Returns the File::Stat object for the last symbolic link in the path
+#         for `self`.
+#
+#
+#
+# *Contents*
+#
+#     ::empty? (aliased as ::zero?)
+# :       Returns whether the file at the given path exists and is empty.
+#
+#     ::size
+# :       Returns the size (bytes) of the file at the given path.
+#
+#     ::size?
+# :       Returns `nil` if there is no file at the given path, or if that file
+#         is empty; otherwise returns the file size (bytes).
+#
+#     #size
+# :       Returns the size (bytes) of `self`.
+#
+#
+#
+# ### Settings
+#
+#     ::chmod
+# :       Changes permissions of the file at the given path.
+#
+#     ::chown
+# :       Change ownership of the file at the given path.
+#
+#     ::lchmod
+# :       Changes permissions of the last symbolic link in the given path.
+#
+#     ::lchown
+# :       Change ownership of the last symbolic in the given path.
+#
+#     ::lutime
+# :       For each given file path, sets the access time and modification time
+#         of the last symbolic link in the path.
+#
+#     ::rename
+# :       Moves the file at one given path to another given path.
+#
+#     ::utime
+# :       Sets the access time and modification time of each file at the given
+#         paths.
+#
+#     #flock
+# :       Locks or unlocks `self`.
+#
+#
+#
+# ### Other
+#
+#     ::truncate
+# :       Truncates the file at the given file path to the given size.
+#
+#     ::unlink (aliased as ::delete)
+# :       Deletes the file for each given file path.
+#
+#     #truncate
+# :       Truncates `self` to the given size.
+#
 class File < IO
+  # <!--
+  #   rdoc-file=io.c
+  #   - File.new(filename, mode="r" [, opt])            -> file
+  #   - File.new(filename [, mode [, perm]] [, opt])    -> file
+  # -->
   # Opens the file named by `filename` according to the given `mode` and returns a
   # new File object.
   #
@@ -44,8 +324,12 @@ class File < IO
   #     f = File.new("newfile",  "w+")
   #     f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
   #
-  def initialize: (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) -> File
+  def initialize: (string | _ToPath | int file_name, ?string | int mode, ?int perm) -> File
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.absolute_path(file_name [, dir_string] )  ->  abs_file_name
+  # -->
   # Converts a pathname to an absolute pathname. Relative paths are referenced
   # from the current working directory of the process unless *dir_string* is
   # given, in which case it will be used as the starting point. If the given
@@ -54,14 +338,22 @@ class File < IO
   #
   #     File.absolute_path("~oracle/bin")       #=> "<relative_path>/~oracle/bin"
   #
-  def self.absolute_path: (string | _ToPath file_name, ?(string | _ToPath) dir_string) -> String
+  def self.absolute_path: (string | _ToPath file_name, ?string | _ToPath dir_string) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.absolute_path?(file_name)  ->  true or false
+  # -->
   # Returns `true` if `file_name` is an absolute path, and `false` otherwise.
   #
   #     File.absolute_path?("c:/foo")     #=> false (on Linux), true (on Windows)
   #
   def self.absolute_path?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.atime(file_name)  ->  time
+  # -->
   # Returns the last access time for the named file as a Time object.
   #
   # *file_name* can be an IO object.
@@ -70,6 +362,10 @@ class File < IO
   #
   def self.atime: (string | _ToPath | IO file_name) -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.basename(file_name [, suffix] )  ->  base_name
+  # -->
   # Returns the last component of the filename given in *file_name* (after first
   # stripping trailing separators), which can be formed using both File::SEPARATOR
   # and File::ALT_SEPARATOR as the separator when File::ALT_SEPARATOR is not
@@ -82,20 +378,37 @@ class File < IO
   #
   def self.basename: (string | _ToPath file_name, ?string suffix) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - birthtime(p1)
+  # -->
+  #
   def self.birthtime: (string | _ToPath | IO file_name) -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.blockdev?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a block device.
   #
   # *file_name* can be an IO object.
   #
   def self.blockdev?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.chardev?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a character device.
   #
   # *file_name* can be an IO object.
   #
   def self.chardev?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.chmod(mode_int, file_name, ... )  ->  integer
+  # -->
   # Changes permission bits on the named file(s) to the bit pattern represented by
   # *mode_int*. Actual effects are operating system dependent (see the beginning
   # of this section). On Unix systems, see `chmod(2)` for details. Returns the
@@ -103,8 +416,12 @@ class File < IO
   #
   #     File.chmod(0644, "testfile", "out")   #=> 2
   #
-  def self.chmod: (int mode, *(string | _ToPath) file_name) -> Integer
+  def self.chmod: (int mode, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.chown(owner_int, group_int, file_name, ...)  ->  integer
+  # -->
   # Changes the owner and group of the named file(s) to the given numeric owner
   # and group id's. Only a process with superuser privileges may change the owner
   # of a file. The current owner of a file may change the file's group to any
@@ -113,8 +430,12 @@ class File < IO
   #
   #     File.chown(nil, 100, "testfile")
   #
-  def self.chown: (int? owner, int? group, *(string | _ToPath) file_name) -> Integer
+  def self.chown: (int? owner, int? group, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.ctime(file_name)  -> time
+  # -->
   # Returns the change time for the named file (the time at which directory
   # information about the file was changed, not the file itself).
   #
@@ -126,6 +447,11 @@ class File < IO
   #
   def self.ctime: (string | _ToPath | IO file_name) -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.delete(file_name, ...)  -> integer
+  #   - File.unlink(file_name, ...)  -> integer
+  # -->
   # Deletes the named files, returning the number of names passed as arguments.
   # Raises an exception on any error. Since the underlying implementation relies
   # on the `unlink(2)` system call, the type of exception raised depends on its
@@ -136,6 +462,10 @@ class File < IO
   #
   alias self.delete self.unlink
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.directory?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a directory, or a symlink that points at a
   # directory, and `false` otherwise.
   #
@@ -145,6 +475,10 @@ class File < IO
   #
   def self.directory?: (string | _ToPath | IO path) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.dirname(file_name, level = 1)  ->  dir_name
+  # -->
   # Returns all components of the filename given in *file_name* except the last
   # one (after first stripping trailing separators). The filename can be formed
   # using both File::SEPARATOR and File::ALT_SEPARATOR as the separator when
@@ -152,14 +486,27 @@ class File < IO
   #
   #     File.dirname("/home/gumby/work/ruby.rb")   #=> "/home/gumby/work"
   #
-  def self.dirname: (string | _ToPath file_name) -> String
+  # If `level` is given, removes the last `level` components, not only one.
+  #
+  #     File.dirname("/home/gumby/work/ruby.rb", 2) #=> "/home/gumby"
+  #     File.dirname("/home/gumby/work/ruby.rb", 4) #=> "/"
+  #
+  def self.dirname: (string | _ToPath file_name, ?Integer level) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.zero?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file exists and has a zero size.
   #
   # *file_name* can be an IO object.
   #
   alias self.empty? self.zero?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.executable?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is executable by the effective user and group
   # id of this process. See eaccess(3).
   #
@@ -172,6 +519,10 @@ class File < IO
   #
   def self.executable?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.executable_real?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is executable by the real user and group id
   # of this process. See access(3).
   #
@@ -184,6 +535,10 @@ class File < IO
   #
   def self.executable_real?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.exist?(file_name)    ->  true or false
+  # -->
   # Return `true` if the named file exists.
   #
   # *file_name* can be an IO object.
@@ -192,6 +547,10 @@ class File < IO
   #
   def self.exist?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.expand_path(file_name [, dir_string] )  ->  abs_file_name
+  # -->
   # Converts a pathname to an absolute pathname. Relative paths are referenced
   # from the current working directory of the process unless `dir_string` is
   # given, in which case it will be used as the starting point. The given pathname
@@ -213,8 +572,12 @@ class File < IO
   # So first it resolves the parent of __FILE__, that is bin/, then go to the
   # parent, the root of the project and appends `lib/mygem.rb`.
   #
-  def self.expand_path: (string | _ToPath file_name, ?(string | _ToPath) dir_string) -> String
+  def self.expand_path: (string | _ToPath file_name, ?string | _ToPath dir_string) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.extname(path)  ->  string
+  # -->
   # Returns the extension (the portion of file name in `path` starting from the
   # last period).
   #
@@ -237,6 +600,10 @@ class File < IO
   #
   def self.extname: (string | _ToPath path) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.file?(file) -> true or false
+  # -->
   # Returns `true` if the named `file` exists and is a regular file.
   #
   # `file` can be an IO object.
@@ -246,16 +613,21 @@ class File < IO
   #
   def self.file?: (string | _ToPath | IO file) -> bool
 
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - File.fnmatch( pattern, path, [flags] ) -> (true or false)
+  #   - File.fnmatch?( pattern, path, [flags] ) -> (true or false)
+  # -->
   # Returns true if `path` matches against `pattern`.  The pattern is not a
   # regular expression; instead it follows rules similar to shell filename
   # globbing.  It may contain the following metacharacters:
   #
   # `*`
   # :   Matches any file. Can be restricted by other values in the glob.
-  #     Equivalent to `/ .* /x` in regexp.
+  #     Equivalent to `/.*/x` in regexp.
   #
   #     `*`
-  # :       Matches all files regular files
+  # :       Matches all regular files
   #     `c*`
   # :       Matches all files beginning with `c`
   #     `*c`
@@ -265,7 +637,7 @@ class File < IO
   #         end).
   #
   #
-  #     To match hidden files (that start with a `.` set the File::FNM_DOTMATCH
+  #     To match hidden files (that start with a `.`) set the File::FNM_DOTMATCH
   #     flag.
   #
   # `**`
@@ -278,7 +650,7 @@ class File < IO
   # :   Matches any one character in `set`.  Behaves exactly like character sets
   #     in Regexp, including set negation (`[^a-z]`).
   #
-  # ` \ `
+  # `\`
   # :   Escapes the next metacharacter.
   #
   # `{a,b}`
@@ -321,125 +693,33 @@ class File < IO
   #     File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true  # period by default.
   #     File.fnmatch('.*',  '.profile')                      #=> true
   #
-  #     rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
-  #     File.fnmatch(rbfiles, 'main.rb')                    #=> false
-  #     File.fnmatch(rbfiles, './main.rb')                  #=> false
-  #     File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
+  #     File.fnmatch('**/*.rb', 'main.rb')                  #=> false
+  #     File.fnmatch('**/*.rb', './main.rb')                #=> false
+  #     File.fnmatch('**/*.rb', 'lib/song.rb')              #=> true
   #     File.fnmatch('**.rb', 'main.rb')                    #=> true
   #     File.fnmatch('**.rb', './main.rb')                  #=> false
   #     File.fnmatch('**.rb', 'lib/song.rb')                #=> true
-  #     File.fnmatch('*',           'dave/.profile')                      #=> true
+  #     File.fnmatch('*',     'dave/.profile')              #=> true
   #
-  #     pattern = '*' '/' '*'
-  #     File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
-  #     File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
-  #
-  #     pattern = '**' '/' 'foo'
-  #     File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
-  #     File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
-  #     File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
-  #     File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
-  #     File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
+  #     File.fnmatch('**/foo', 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
+  #     File.fnmatch('**/foo', '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
+  #     File.fnmatch('**/foo', 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
+  #     File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
+  #     File.fnmatch('**/foo', 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
   #
   def self.fnmatch: (string pattern, string | _ToPath path, ?int flags) -> bool
 
-  # Returns true if `path` matches against `pattern`.  The pattern is not a
-  # regular expression; instead it follows rules similar to shell filename
-  # globbing.  It may contain the following metacharacters:
-  #
-  # `*`
-  # :   Matches any file. Can be restricted by other values in the glob.
-  #     Equivalent to `/ .* /x` in regexp.
-  #
-  #     `*`
-  # :       Matches all files regular files
-  #     `c*`
-  # :       Matches all files beginning with `c`
-  #     `*c`
-  # :       Matches all files ending with `c`
-  #     `*c*`
-  # :       Matches all files that have `c` in them (including at the beginning or
-  #         end).
-  #
-  #
-  #     To match hidden files (that start with a `.` set the File::FNM_DOTMATCH
-  #     flag.
-  #
-  # `**`
-  # :   Matches directories recursively or files expansively.
-  #
-  # `?`
-  # :   Matches any one character. Equivalent to `/.{1}/` in regexp.
-  #
-  # `[set]`
-  # :   Matches any one character in `set`.  Behaves exactly like character sets
-  #     in Regexp, including set negation (`[^a-z]`).
-  #
-  # ` \ `
-  # :   Escapes the next metacharacter.
-  #
-  # `{a,b}`
-  # :   Matches pattern a and pattern b if File::FNM_EXTGLOB flag is enabled.
-  #     Behaves like a Regexp union (`(?:a|b)`).
-  #
-  #
-  # `flags` is a bitwise OR of the `FNM_XXX` constants. The same glob pattern and
-  # flags are used by Dir::glob.
-  #
-  # Examples:
-  #
-  #     File.fnmatch('cat',       'cat')        #=> true  # match entire string
-  #     File.fnmatch('cat',       'category')   #=> false # only match partial string
-  #
-  #     File.fnmatch('c{at,ub}s', 'cats')                    #=> false # { } isn't supported by default
-  #     File.fnmatch('c{at,ub}s', 'cats', File::FNM_EXTGLOB) #=> true  # { } is supported on FNM_EXTGLOB
-  #
-  #     File.fnmatch('c?t',     'cat')          #=> true  # '?' match only 1 character
-  #     File.fnmatch('c??t',    'cat')          #=> false # ditto
-  #     File.fnmatch('c*',      'cats')         #=> true  # '*' match 0 or more characters
-  #     File.fnmatch('c*t',     'c/a/b/t')      #=> true  # ditto
-  #     File.fnmatch('ca[a-z]', 'cat')          #=> true  # inclusive bracket expression
-  #     File.fnmatch('ca[^t]',  'cat')          #=> false # exclusive bracket expression ('^' or '!')
-  #
-  #     File.fnmatch('cat', 'CAT')                     #=> false # case sensitive
-  #     File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  # case insensitive
-  #     File.fnmatch('cat', 'CAT', File::FNM_SYSCASE)  #=> true or false # depends on the system default
-  #
-  #     File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false # wildcard doesn't match '/' on FNM_PATHNAME
-  #     File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false # ditto
-  #     File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false # ditto
-  #
-  #     File.fnmatch('\?',   '?')                       #=> true  # escaped wildcard becomes ordinary
-  #     File.fnmatch('\a',   'a')                       #=> true  # escaped ordinary remains ordinary
-  #     File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  # FNM_NOESCAPE makes '\' ordinary
-  #     File.fnmatch('[\?]', '?')                       #=> true  # can escape inside bracket expression
-  #
-  #     File.fnmatch('*',   '.profile')                      #=> false # wildcard doesn't match leading
-  #     File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true  # period by default.
-  #     File.fnmatch('.*',  '.profile')                      #=> true
-  #
-  #     rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
-  #     File.fnmatch(rbfiles, 'main.rb')                    #=> false
-  #     File.fnmatch(rbfiles, './main.rb')                  #=> false
-  #     File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
-  #     File.fnmatch('**.rb', 'main.rb')                    #=> true
-  #     File.fnmatch('**.rb', './main.rb')                  #=> false
-  #     File.fnmatch('**.rb', 'lib/song.rb')                #=> true
-  #     File.fnmatch('*',           'dave/.profile')                      #=> true
-  #
-  #     pattern = '*' '/' '*'
-  #     File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
-  #     File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
-  #
-  #     pattern = '**' '/' 'foo'
-  #     File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
-  #     File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
-  #     File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
-  #     File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
-  #     File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
+  # <!--
+  #   rdoc-file=dir.rb
+  #   - fnmatch?(pattern, path, flags = 0)
+  # -->
   #
   alias self.fnmatch? self.fnmatch
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.ftype(file_name)   -> string
+  # -->
   # Identifies the type of the named file; the return string is one of ```file`'',
   # ```directory`'', ```characterSpecial`'', ```blockSpecial`'', ```fifo`'',
   # ```link`'', ```socket`'', or ```unknown`''.
@@ -450,6 +730,10 @@ class File < IO
   #
   def self.ftype: (string | _ToPath file_name) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.grpowned?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file exists and the effective group id of the
   # calling process is the owner of the file. Returns `false` on Windows.
   #
@@ -457,6 +741,10 @@ class File < IO
   #
   def self.grpowned?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.identical?(file_1, file_2)   ->  true or false
+  # -->
   # Returns `true` if the named files are identical.
   #
   # *file_1* and *file_2* can be an IO object.
@@ -473,24 +761,40 @@ class File < IO
   #
   def self.identical?: (string | _ToPath | IO file_1, string | _ToPath | IO file_2) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.join(string, ...)  ->  string
+  # -->
   # Returns a new string formed by joining the strings using `"/"`.
   #
   #     File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"
   #
   def self.join: (*string) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.lchmod(mode_int, file_name, ...)  -> integer
+  # -->
   # Equivalent to File::chmod, but does not follow symbolic links (so it will
   # change the permissions associated with the link, not the file referenced by
   # the link). Often not available.
   #
-  def self.lchmod: (int mode, *(string | _ToPath) file_name) -> Integer
+  def self.lchmod: (int mode, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.lchown(owner_int, group_int, file_name,..) -> integer
+  # -->
   # Equivalent to File::chown, but does not follow symbolic links (so it will
   # change the owner associated with the link, not the file referenced by the
   # link). Often not available. Returns number of files in the argument list.
   #
-  def self.lchown: (int? owner, int? group, *(string | _ToPath) file_name) -> Integer
+  def self.lchown: (int? owner, int? group, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.link(old_name, new_name)    -> 0
+  # -->
   # Creates a new name for an existing file using a hard link. Will not overwrite
   # *new_name* if it already exists (raising a subclass of SystemCallError). Not
   # available on all platforms.
@@ -500,6 +804,10 @@ class File < IO
   #
   def self.link: (string | _ToPath old_name, string | _ToPath new_name) -> 0
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.lstat(file_name)   -> stat
+  # -->
   # Same as File::stat, but does not follow the last symbolic link. Instead,
   # reports on the link itself.
   #
@@ -510,19 +818,31 @@ class File < IO
   #
   def self.lstat: (string | _ToPath file_name) -> File::Stat
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.lutime(atime, mtime, file_name, ...)   ->  integer
+  # -->
   # Sets the access and modification times of each named file to the first two
   # arguments. If a file is a symlink, this method acts upon the link itself as
   # opposed to its referent; for the inverse behavior, see File.utime. Returns the
   # number of file names in the argument list.
   #
-  def self.lutime: ((Time | Numeric) atime, (Time | Numeric) mtime, *(string | _ToPath) file_name) -> Integer
+  def self.lutime: (Time | Numeric atime, Time | Numeric mtime, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.mkfifo(file_name, mode=0666)  => 0
+  # -->
   # Creates a FIFO special file with name *file_name*.  *mode* specifies the
   # FIFO's permissions. It is modified by the process's umask in the usual way:
   # the permissions of the created file are (mode & ~umask).
   #
-  def self.mkfifo: ((string | _ToPath) file_name, ?int mode) -> 0
+  def self.mkfifo: (string | _ToPath file_name, ?int mode) -> 0
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.mtime(file_name)  ->  time
+  # -->
   # Returns the modification time for the named file as a Time object.
   #
   # *file_name* can be an IO object.
@@ -531,10 +851,30 @@ class File < IO
   #
   def self.mtime: (string | _ToPath | IO file_name) -> Time
 
-  # Alias of `File.new`.
-  def self.open: (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) -> instance
-               | [T] (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) { (File) -> T } -> T
-
+  # <!--
+  #   rdoc-file=io.c
+  #   - File.open(filename, mode="r" [, opt])                 -> file
+  #   - File.open(filename [, mode [, perm]] [, opt])         -> file
+  #   - File.open(filename, mode="r" [, opt]) {|file| block } -> obj
+  #   - File.open(filename [, mode [, perm]] [, opt]) {|file| block } -> obj
+  # -->
+  # With no associated block, File.open is a synonym for File.new. If the optional
+  # code block is given, it will be passed the opened `file` as an argument and
+  # the File object will automatically be closed when the block terminates.  The
+  # value of the block will be returned from File.open.
+  #
+  # If a file is being created, its initial permissions may be set using the
+  # `perm` parameter.  See File.new for further discussion.
+  #
+  # See IO.new for a description of the `mode` and `opt` parameters.
+  #
+  def self.open: (string | _ToPath | int file_name, ?string | int mode, ?int perm) -> instance
+               | [T] (string | _ToPath | int file_name, ?string | int mode, ?int perm) { (File) -> T } -> T
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.owned?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file exists and the effective used id of the
   # calling process is the owner of the file.
   #
@@ -542,6 +882,10 @@ class File < IO
   #
   def self.owned?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.path(path)  ->  string
+  # -->
   # Returns the string representation of the path
   #
   #     File.path("/dev/null")          #=> "/dev/null"
@@ -549,12 +893,20 @@ class File < IO
   #
   def self.path: (string | _ToPath path) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.pipe?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a pipe.
   #
   # *file_name* can be an IO object.
   #
   def self.pipe?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.readable?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is readable by the effective user and group
   # id of this process. See eaccess(3).
   #
@@ -563,6 +915,10 @@ class File < IO
   #
   def self.readable?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.readable_real?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is readable by the real user and group id of
   # this process. See access(3).
   #
@@ -571,6 +927,10 @@ class File < IO
   #
   def self.readable_real?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.readlink(link_name)  ->  file_name
+  # -->
   # Returns the name of the file referenced by the given link. Not available on
   # all platforms.
   #
@@ -579,6 +939,10 @@ class File < IO
   #
   def self.readlink: (string | _ToPath link_name) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.realdirpath(pathname [, dir_string])  ->  real_pathname
+  # -->
   # Returns the real (absolute) pathname of *pathname* in the actual filesystem.
   # The real pathname doesn't contain symlinks or useless dots.
   #
@@ -587,8 +951,12 @@ class File < IO
   #
   # The last component of the real pathname can be nonexistent.
   #
-  def self.realdirpath: (string | _ToPath pathname, ?(string | _ToPath) dir_string) -> String
+  def self.realdirpath: (string | _ToPath pathname, ?string | _ToPath dir_string) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.realpath(pathname [, dir_string])  ->  real_pathname
+  # -->
   # Returns the real (absolute) pathname of *pathname* in the actual filesystem
   # not containing symlinks or useless dots.
   #
@@ -597,8 +965,12 @@ class File < IO
   #
   # All components of the pathname must exist when this method is called.
   #
-  def self.realpath: (string | _ToPath pathname, ?(string | _ToPath) dir_string) -> String
+  def self.realpath: (string | _ToPath pathname, ?string | _ToPath dir_string) -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.rename(old_name, new_name)   -> 0
+  # -->
   # Renames the given file to the new name. Raises a SystemCallError if the file
   # cannot be renamed.
   #
@@ -606,24 +978,40 @@ class File < IO
   #
   def self.rename: (string | _ToPath old_name, string | _ToPath new_name) -> 0
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.setgid?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file has the setgid bit set.
   #
   # *file_name* can be an IO object.
   #
   def self.setgid?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.setuid?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file has the setuid bit set.
   #
   # *file_name* can be an IO object.
   #
   def self.setuid?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.size(file_name)   -> integer
+  # -->
   # Returns the size of `file_name`.
   #
   # *file_name* can be an IO object.
   #
   def self.size: (string | _ToPath | IO file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.size?(file_name)   -> Integer or nil
+  # -->
   # Returns `nil` if `file_name` doesn't exist or has zero size, the size of the
   # file otherwise.
   #
@@ -631,31 +1019,51 @@ class File < IO
   #
   def self.size?: (string | _ToPath | IO file_name) -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.socket?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a socket.
   #
   # *file_name* can be an IO object.
   #
   def self.socket?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.split(file_name)   -> array
+  # -->
   # Splits the given string into a directory and a file component and returns them
   # in a two-element array. See also File::dirname and File::basename.
   #
   #     File.split("/home/gumby/.profile")   #=> ["/home/gumby", ".profile"]
   #
-  def self.split: (string | _ToPath file_name) -> [String, String]
+  def self.split: (string | _ToPath file_name) -> [ String, String ]
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.stat(file_name)   ->  stat
+  # -->
   # Returns a File::Stat object for the named file (see File::Stat).
   #
   #     File.stat("testfile").mtime   #=> Tue Apr 08 12:58:04 CDT 2003
   #
   def self.stat: (string | _ToPath file_name) -> File::Stat
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.sticky?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file has the sticky bit set.
   #
   # *file_name* can be an IO object.
   #
   def self.sticky?: (string | _ToPath | IO file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.symlink(old_name, new_name)   -> 0
+  # -->
   # Creates a symbolic link called *new_name* for the existing file *old_name*.
   # Raises a NotImplemented exception on platforms that do not support symbolic
   # links.
@@ -664,10 +1072,18 @@ class File < IO
   #
   def self.symlink: (string | _ToPath old_name, string | _ToPath new_name) -> 0
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.symlink?(file_name)   ->  true or false
+  # -->
   # Returns `true` if the named file is a symbolic link.
   #
   def self.symlink?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.truncate(file_name, integer)  -> 0
+  # -->
   # Truncates the file *file_name* to be at most *integer* bytes long. Not
   # available on all platforms.
   #
@@ -679,6 +1095,11 @@ class File < IO
   #
   def self.truncate: (string | _ToPath file_name, int length) -> 0
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.umask()          -> integer
+  #   - File.umask(integer)   -> integer
+  # -->
   # Returns the current umask value for this process. If the optional argument is
   # given, set the umask to that value and return the previous value. Umask values
   # are *subtracted* from the default permissions, so a umask of `0222` would make
@@ -689,6 +1110,11 @@ class File < IO
   #
   def self.umask: (?int umask) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.delete(file_name, ...)  -> integer
+  #   - File.unlink(file_name, ...)  -> integer
+  # -->
   # Deletes the named files, returning the number of names passed as arguments.
   # Raises an exception on any error. Since the underlying implementation relies
   # on the `unlink(2)` system call, the type of exception raised depends on its
@@ -697,15 +1123,23 @@ class File < IO
   #
   # See also Dir::rmdir.
   #
-  def self.unlink: (*(string | _ToPath) file_name) -> Integer
+  def self.unlink: (*string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.utime(atime, mtime, file_name, ...)   ->  integer
+  # -->
   # Sets the access and modification times of each named file to the first two
   # arguments. If a file is a symlink, this method acts upon its referent rather
   # than the link itself; for the inverse behavior see File.lutime. Returns the
   # number of file names in the argument list.
   #
-  def self.utime: ((Time | Numeric) atime, (Time | Numeric) mtime, *(string | _ToPath) file_name) -> Integer
+  def self.utime: (Time | Numeric atime, Time | Numeric mtime, *string | _ToPath file_name) -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.world_readable?(file_name)   -> integer or nil
+  # -->
   # If *file_name* is readable by others, returns an integer representing the file
   # permission bits of *file_name*. Returns `nil` otherwise. The meaning of the
   # bits is platform dependent; on Unix systems, see `stat(2)`.
@@ -718,6 +1152,10 @@ class File < IO
   #
   def self.world_readable?: (string | _ToPath | IO file_name) -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.world_writable?(file_name)   -> integer or nil
+  # -->
   # If *file_name* is writable by others, returns an integer representing the file
   # permission bits of *file_name*. Returns `nil` otherwise. The meaning of the
   # bits is platform dependent; on Unix systems, see `stat(2)`.
@@ -730,6 +1168,10 @@ class File < IO
   #
   def self.world_writable?: (string | _ToPath | IO file_name) -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.writable?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is writable by the effective user and group
   # id of this process. See eaccess(3).
   #
@@ -738,6 +1180,10 @@ class File < IO
   #
   def self.writable?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.writable_real?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file is writable by the real user and group id of
   # this process. See access(3).
   #
@@ -746,6 +1192,10 @@ class File < IO
   #
   def self.writable_real?: (string | _ToPath file_name) -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.zero?(file_name)   -> true or false
+  # -->
   # Returns `true` if the named file exists and has a zero size.
   #
   # *file_name* can be an IO object.
@@ -754,6 +1204,10 @@ class File < IO
 
   public
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.atime    -> time
+  # -->
   # Returns the last access time (a Time object) for *file*, or epoch if *file*
   # has not been accessed.
   #
@@ -761,6 +1215,10 @@ class File < IO
   #
   def atime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.birthtime  ->  time
+  # -->
   # Returns the birth time for *file*.
   #
   #     File.new("testfile").birthtime   #=> Wed Apr 09 08:53:14 CDT 2003
@@ -769,6 +1227,10 @@ class File < IO
   #
   def birthtime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.chmod(mode_int)   -> 0
+  # -->
   # Changes permission bits on *file* to the bit pattern represented by
   # *mode_int*. Actual effects are platform dependent; on Unix systems, see
   # `chmod(2)` for details. Follows symbolic links. Also see File#lchmod.
@@ -778,6 +1240,10 @@ class File < IO
   #
   def chmod: (int mode) -> (0 | nil)
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.chown(owner_int, group_int )   -> 0
+  # -->
   # Changes the owner and group of *file* to the given numeric owner and group
   # id's. Only a process with superuser privileges may change the owner of a file.
   # The current owner of a file may change the file's group to any group to which
@@ -788,6 +1254,10 @@ class File < IO
   #
   def chown: (int? owner, int? group) -> (0 | nil)
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.ctime  ->  time
+  # -->
   # Returns the change time for *file* (that is, the time directory information
   # about the file was changed, not the file itself).
   #
@@ -797,6 +1267,10 @@ class File < IO
   #
   def ctime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.flock(locking_constant) -> 0 or false
+  # -->
   # Locks or unlocks a file according to *locking_constant* (a logical *or* of the
   # values in the table below). Returns `false` if File::LOCK_NB is specified and
   # the operation would otherwise have blocked. Not available on all platforms.
@@ -835,6 +1309,10 @@ class File < IO
   #
   def flock: (int locking_constant) -> (0 | false)
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.lstat   ->  stat
+  # -->
   # Same as IO#stat, but does not follow the last symbolic link. Instead, reports
   # on the link itself.
   #
@@ -846,12 +1324,21 @@ class File < IO
   #
   def lstat: () -> (File::Stat | nil)
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.mtime  ->  time
+  # -->
   # Returns the modification time for *file*.
   #
   #     File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
   #
   def mtime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.path  ->  filename
+  #   - file.to_path  ->  filename
+  # -->
   # Returns the pathname used to create *file* as a string. Does not normalize the
   # name.
   #
@@ -866,12 +1353,14 @@ class File < IO
   #
   def path: () -> String
 
-  # Returns the size of *file* in bytes.
-  #
-  #     File.new("testfile").size   #=> 66
+  # <!--
+  #   rdoc-file=file.c
+  #   - size()
+  # -->
   #
   def size: () -> Integer
 
+  # <!-- rdoc-file=file.c -->
   # Returns the pathname used to create *file* as a string. Does not normalize the
   # name.
   #
@@ -886,6 +1375,10 @@ class File < IO
   #
   alias to_path path
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - file.truncate(integer)    -> 0
+  # -->
   # Truncates *file* to at most *integer* bytes. The file must be opened for
   # writing. Not available on all platforms.
   #
@@ -898,24 +1391,24 @@ class File < IO
   def truncate: (int length) -> 0
 end
 
+# <!-- rdoc-file=file.c -->
 # platform specific alternative separator
 #
-#
 File::ALT_SEPARATOR: String?
 
+# <!-- rdoc-file=file.c -->
 # path list separator
 #
-#
 File::PATH_SEPARATOR: String
 
+# <!-- rdoc-file=file.c -->
 # separates directory parts in path
 #
-#
 File::SEPARATOR: String
 
+# <!-- rdoc-file=file.c -->
 # separates directory parts in path
 #
-#
 File::Separator: String
 
 module File::Constants
@@ -981,96 +1474,521 @@ File::Constants::TRUNC: Integer
 
 File::Constants::WRONLY: Integer
 
+# <!-- rdoc-file=file.c -->
+# Objects of class File::Stat encapsulate common status information for File
+# objects. The information is recorded at the moment the File::Stat object is
+# created; changes made to the file after that point will not be reflected.
+# File::Stat objects are returned by IO#stat, File::stat, File#lstat, and
+# File::lstat. Many of these methods return platform-specific values, and not
+# all values are meaningful on all systems. See also Kernel#test.
+#
 class File::Stat < Object
   include Comparable
 
-  def initialize: (String file) -> Object
+  # <!--
+  #   rdoc-file=file.c
+  #   - File::Stat.new(file_name)  -> stat
+  # -->
+  # Create a File::Stat object for the given file name (raising an exception if
+  # the file doesn't exist).
+  #
+  def initialize: (String file) -> void
+
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat <=> other_stat    -> -1, 0, 1, nil
+  # -->
+  # Compares File::Stat objects by comparing their respective modification times.
+  #
+  # `nil` is returned if `other_stat` is not a File::Stat object
+  #
+  #     f1 = File.new("f1", "w")
+  #     sleep 1
+  #     f2 = File.new("f2", "w")
+  #     f1.stat <=> f2.stat   #=> -1
+  #
   def <=>: (File::Stat other) -> Integer
          | (untyped) -> nil
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.atime   -> time
+  # -->
+  # Returns the last access time for this file as an object of class Time.
+  #
+  #     File.stat("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969
+  #
   def atime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.birthtime  ->  aTime
+  # -->
+  # Returns the birth time for *stat*.
+  #
+  # If the platform doesn't have birthtime, raises NotImplementedError.
+  #
+  #     File.write("testfile", "foo")
+  #     sleep 10
+  #     File.write("testfile", "bar")
+  #     sleep 10
+  #     File.chmod(0644, "testfile")
+  #     sleep 10
+  #     File.read("testfile")
+  #     File.stat("testfile").birthtime   #=> 2014-02-24 11:19:17 +0900
+  #     File.stat("testfile").mtime       #=> 2014-02-24 11:19:27 +0900
+  #     File.stat("testfile").ctime       #=> 2014-02-24 11:19:37 +0900
+  #     File.stat("testfile").atime       #=> 2014-02-24 11:19:47 +0900
+  #
   def birthtime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blksize   -> integer or nil
+  # -->
+  # Returns the native file system's block size. Will return `nil` on platforms
+  # that don't support this information.
+  #
+  #     File.stat("testfile").blksize   #=> 4096
+  #
   def blksize: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blockdev?   -> true or false
+  # -->
+  # Returns `true` if the file is a block device, `false` if it isn't or if the
+  # operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").blockdev?    #=> false
+  #     File.stat("/dev/hda1").blockdev?   #=> true
+  #
   def blockdev?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.blocks    -> integer or nil
+  # -->
+  # Returns the number of native file system blocks allocated for this file, or
+  # `nil` if the operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").blocks   #=> 2
+  #
   def blocks: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.chardev?    -> true or false
+  # -->
+  # Returns `true` if the file is a character device, `false` if it isn't or if
+  # the operating system doesn't support this feature.
+  #
+  #     File.stat("/dev/tty").chardev?   #=> true
+  #
   def chardev?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ctime  ->  aTime
+  # -->
+  # Returns the change time for *stat* (that is, the time directory information
+  # about the file was changed, not the file itself).
+  #
+  # Note that on Windows (NTFS), returns creation time (birth time).
+  #
+  #     File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003
+  #
   def ctime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev    -> integer
+  # -->
+  # Returns an integer representing the device on which *stat* resides.
+  #
+  #     File.stat("testfile").dev   #=> 774
+  #
   def dev: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev_major   -> integer
+  # -->
+  # Returns the major part of `File_Stat#dev` or `nil`.
+  #
+  #     File.stat("/dev/fd1").dev_major   #=> 2
+  #     File.stat("/dev/tty").dev_major   #=> 5
+  #
   def dev_major: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.dev_minor   -> integer
+  # -->
+  # Returns the minor part of `File_Stat#dev` or `nil`.
+  #
+  #     File.stat("/dev/fd1").dev_minor   #=> 1
+  #     File.stat("/dev/tty").dev_minor   #=> 0
+  #
   def dev_minor: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - File.directory?(file_name)   ->  true or false
+  # -->
+  # Returns `true` if the named file is a directory, or a symlink that points at a
+  # directory, and `false` otherwise.
+  #
+  # *file_name* can be an IO object.
+  #
+  #     File.directory?(".")
+  #
   def directory?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.executable?    -> true or false
+  # -->
+  # Returns `true` if *stat* is executable or if the operating system doesn't
+  # distinguish executable files from nonexecutable files. The tests are made
+  # using the effective owner of the process.
+  #
+  #     File.stat("testfile").executable?   #=> false
+  #
   def executable?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.executable_real?    -> true or false
+  # -->
+  # Same as `executable?`, but tests using the real owner of the process.
+  #
   def executable_real?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.file?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a regular file (not a device file, pipe, socket,
+  # etc.).
+  #
+  #     File.stat("testfile").file?   #=> true
+  #
   def file?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ftype   -> string
+  # -->
+  # Identifies the type of *stat*. The return string is one of: ```file`'',
+  # ```directory`'', ```characterSpecial`'', ```blockSpecial`'', ```fifo`'',
+  # ```link`'', ```socket`'', or ```unknown`''.
+  #
+  #     File.stat("/dev/tty").ftype   #=> "characterSpecial"
+  #
   def ftype: () -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.gid   -> integer
+  # -->
+  # Returns the numeric group id of the owner of *stat*.
+  #
+  #     File.stat("testfile").gid   #=> 500
+  #
   def gid: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.grpowned?   -> true or false
+  # -->
+  # Returns true if the effective group id of the process is the same as the group
+  # id of *stat*. On Windows NT, returns `false`.
+  #
+  #     File.stat("testfile").grpowned?      #=> true
+  #     File.stat("/etc/passwd").grpowned?   #=> false
+  #
   def grpowned?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.ino   -> integer
+  # -->
+  # Returns the inode number for *stat*.
+  #
+  #     File.stat("testfile").ino   #=> 1083669
+  #
   def ino: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.inspect  ->  string
+  # -->
+  # Produce a nicely formatted description of *stat*.
+  #
+  #     File.stat("/etc/passwd").inspect
+  #        #=> "#<File::Stat dev=0xe000005, ino=1078078, mode=0100644,
+  #        #    nlink=1, uid=0, gid=0, rdev=0x0, size=1374, blksize=4096,
+  #        #    blocks=8, atime=Wed Dec 10 10:16:12 CST 2003,
+  #        #    mtime=Fri Sep 12 15:41:41 CDT 2003,
+  #        #    ctime=Mon Oct 27 11:20:27 CST 2003,
+  #        #    birthtime=Mon Aug 04 08:13:49 CDT 2003>"
+  #
   def inspect: () -> String
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.mode   -> integer
+  # -->
+  # Returns an integer representing the permission bits of *stat*. The meaning of
+  # the bits is platform dependent; on Unix systems, see `stat(2)`.
+  #
+  #     File.chmod(0644, "testfile")   #=> 1
+  #     s = File.stat("testfile")
+  #     sprintf("%o", s.mode)          #=> "100644"
+  #
   def mode: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.mtime  ->  aTime
+  # -->
+  # Returns the modification time of *stat*.
+  #
+  #     File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
+  #
   def mtime: () -> Time
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.nlink   -> integer
+  # -->
+  # Returns the number of hard links to *stat*.
+  #
+  #     File.stat("testfile").nlink             #=> 1
+  #     File.link("testfile", "testfile.bak")   #=> 0
+  #     File.stat("testfile").nlink             #=> 2
+  #
   def nlink: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.owned?    -> true or false
+  # -->
+  # Returns `true` if the effective user id of the process is the same as the
+  # owner of *stat*.
+  #
+  #     File.stat("testfile").owned?      #=> true
+  #     File.stat("/etc/passwd").owned?   #=> false
+  #
   def owned?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.pipe?    -> true or false
+  # -->
+  # Returns `true` if the operating system supports pipes and *stat* is a pipe;
+  # `false` otherwise.
+  #
   def pipe?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev   ->  integer or nil
+  # -->
+  # Returns an integer representing the device type on which *stat* resides.
+  # Returns `nil` if the operating system doesn't support this feature.
+  #
+  #     File.stat("/dev/fd1").rdev   #=> 513
+  #     File.stat("/dev/tty").rdev   #=> 1280
+  #
   def rdev: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev_major   -> integer
+  # -->
+  # Returns the major part of `File_Stat#rdev` or `nil`.
+  #
+  #     File.stat("/dev/fd1").rdev_major   #=> 2
+  #     File.stat("/dev/tty").rdev_major   #=> 5
+  #
   def rdev_major: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.rdev_minor   -> integer
+  # -->
+  # Returns the minor part of `File_Stat#rdev` or `nil`.
+  #
+  #     File.stat("/dev/fd1").rdev_minor   #=> 1
+  #     File.stat("/dev/tty").rdev_minor   #=> 0
+  #
   def rdev_minor: () -> Integer
 
-  def read: (?int? length, ?string outbuf) -> String?
-
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.readable?    -> true or false
+  # -->
+  # Returns `true` if *stat* is readable by the effective user id of this process.
+  #
+  #     File.stat("testfile").readable?   #=> true
+  #
   def readable?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.readable_real?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is readable by the real user id of this process.
+  #
+  #     File.stat("testfile").readable_real?   #=> true
+  #
   def readable_real?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.setgid?   -> true or false
+  # -->
+  # Returns `true` if *stat* has the set-group-id permission bit set, `false` if
+  # it doesn't or if the operating system doesn't support this feature.
+  #
+  #     File.stat("/usr/sbin/lpc").setgid?   #=> true
+  #
   def setgid?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.setuid?    -> true or false
+  # -->
+  # Returns `true` if *stat* has the set-user-id permission bit set, `false` if it
+  # doesn't or if the operating system doesn't support this feature.
+  #
+  #     File.stat("/bin/su").setuid?   #=> true
+  #
   def setuid?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.size    -> integer
+  # -->
+  # Returns the size of *stat* in bytes.
+  #
+  #     File.stat("testfile").size   #=> 66
+  #
   def size: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.size?    -> Integer or nil
+  # -->
+  # Returns `nil` if *stat* is a zero-length file, the size of the file otherwise.
+  #
+  #     File.stat("testfile").size?   #=> 66
+  #     File.stat("/dev/null").size?  #=> nil
+  #
   def size?: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.socket?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a socket, `false` if it isn't or if the operating
+  # system doesn't support this feature.
+  #
+  #     File.stat("testfile").socket?   #=> false
+  #
   def socket?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.sticky?    -> true or false
+  # -->
+  # Returns `true` if *stat* has its sticky bit set, `false` if it doesn't or if
+  # the operating system doesn't support this feature.
+  #
+  #     File.stat("testfile").sticky?   #=> false
+  #
   def sticky?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.symlink?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a symbolic link, `false` if it isn't or if the
+  # operating system doesn't support this feature. As File::stat automatically
+  # follows symbolic links, #symlink? will always be `false` for an object
+  # returned by File::stat.
+  #
+  #     File.symlink("testfile", "alink")   #=> 0
+  #     File.stat("alink").symlink?         #=> false
+  #     File.lstat("alink").symlink?        #=> true
+  #
   def symlink?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.uid    -> integer
+  # -->
+  # Returns the numeric user id of the owner of *stat*.
+  #
+  #     File.stat("testfile").uid   #=> 501
+  #
   def uid: () -> Integer
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.world_readable? -> integer or nil
+  # -->
+  # If *stat* is readable by others, returns an integer representing the file
+  # permission bits of *stat*. Returns `nil` otherwise. The meaning of the bits is
+  # platform dependent; on Unix systems, see `stat(2)`.
+  #
+  #     m = File.stat("/etc/passwd").world_readable?  #=> 420
+  #     sprintf("%o", m)                              #=> "644"
+  #
   def world_readable?: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.world_writable?  ->  integer or nil
+  # -->
+  # If *stat* is writable by others, returns an integer representing the file
+  # permission bits of *stat*. Returns `nil` otherwise. The meaning of the bits is
+  # platform dependent; on Unix systems, see `stat(2)`.
+  #
+  #     m = File.stat("/tmp").world_writable?         #=> 511
+  #     sprintf("%o", m)                              #=> "777"
+  #
   def world_writable?: () -> Integer?
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.writable?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is writable by the effective user id of this process.
+  #
+  #     File.stat("testfile").writable?   #=> true
+  #
   def writable?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.writable_real?  ->  true or false
+  # -->
+  # Returns `true` if *stat* is writable by the real user id of this process.
+  #
+  #     File.stat("testfile").writable_real?   #=> true
+  #
   def writable_real?: () -> bool
 
+  # <!--
+  #   rdoc-file=file.c
+  #   - stat.zero?    -> true or false
+  # -->
+  # Returns `true` if *stat* is a zero-length file; `false` otherwise.
+  #
+  #     File.stat("testfile").zero?   #=> false
+  #
   def zero?: () -> bool
 end