rbs 1.3.2 → 1.5.1

data/core/range.rbs

@@ -101,7 +101,9 @@ class Range[out Elem] < Object
   # ```
   def begin: () -> Elem      # Begin-less ranges have type of Range[Integer?]
 
-  def bsearch: [U] () { (Elem) -> boolish } -> U?
+  def bsearch: () -> ::Enumerator[Elem, Elem?]
+             | () { (Elem) -> (true | false) } -> Elem?
+             | () { (Elem) -> ::Integer } -> Elem?
 
   def cover?: (untyped obj) -> bool
 
@@ -132,7 +134,7 @@ class Range[out Elem] < Object
   # (10..20).first(3)  #=> [10, 11, 12]
   # ```
   def first: () -> Elem
-           | (?Integer n) -> ::Array[Elem]
+           | (Integer n) -> ::Array[Elem]
 
   # Compute a hash-code for this range. Two ranges with equal begin and end
   # points (using `eql?` ), and the same
@@ -165,7 +167,7 @@ class Range[out Elem] < Object
   # (10...20).last(3)  #=> [17, 18, 19]
   # ```
   def last: () -> Elem
-          | (?Integer n) -> ::Array[Elem]
+          | (Integer n) -> ::Array[Elem]
 
   # Returns the maximum value in the range. Returns `nil` if the begin value
   # of the range larger than the end value. Returns `nil` if the begin value
@@ -178,9 +180,9 @@ class Range[out Elem] < Object
   # (10..20).max    #=> 20
   # ```
   def max: () -> Elem
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem
-         | (?Integer n) -> ::Array[Elem]
-         | (?Integer n) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+         | () { (Elem a, Elem b) -> Integer } -> Elem
+         | (Integer n) -> ::Array[Elem]
+         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]
 
   # Returns the minimum value in the range. Returns `nil` if the begin value
   # of the range is larger than the end value. Returns `nil` if the begin
@@ -193,9 +195,9 @@ class Range[out Elem] < Object
   # (10..20).min    #=> 10
   # ```
   def min: () -> Elem
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem
-         | (?Integer n) -> ::Array[Elem]
-         | (?Integer n) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+         | () { (Elem a, Elem b) -> Integer } -> Elem
+         | (Integer n) -> ::Array[Elem]
+         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]
 
   # Returns the number of elements in the range. Both the begin and the end
   # of the [Range](Range.downloaded.ruby_doc) must be

data/core/string_io.rbs

@@ -164,10 +164,9 @@ class StringIO
 
   # See IO#read.
   #
-  def read: (?Integer length, ?String outbuf) -> String?
+  def read: (?int? length, ?string outbuf) -> String?
 
-  def read_nonblock: (Integer len) -> String
-                   | (Integer len, ?String buf) -> String
+  def read_nonblock: (int len, ?string buf) -> String
 
   def readbyte: () -> Integer
 
@@ -179,8 +178,7 @@ class StringIO
   #
   def readlines: (?String sep, ?Integer limit, ?chomp: boolish) -> ::Array[String]
 
-  def readpartial: (Integer maxlen) -> String
-                 | (Integer maxlen, ?String outbuf) -> String
+  def readpartial: (int maxlen, ?string outbuf) -> String
 
   # Reinitializes the stream with the given *other_StrIO* or *string* and *mode*
   # (see StringIO#new).

data/core/true_class.rbs

@@ -5,13 +5,13 @@
 class TrueClass
   public
 
-  def !: () -> bool
+  def !: () -> false
 
   # And---Returns `false` if *obj* is `nil` or `false`, `true` otherwise.
   #
   def &: (nil) -> false
        | (false) -> false
-       | (untyped obj) -> bool
+       | (untyped obj) -> true
 
   # Case Equality -- For class Object, effectively the same as calling `#==`, but
   # typically overridden by descendants to provide meaningful semantics in `case`
@@ -24,7 +24,7 @@ class TrueClass
   #
   def ^: (nil) -> true
        | (false) -> true
-       | (untyped obj) -> bool
+       | (untyped obj) -> false
 
   alias inspect to_s
 
@@ -42,5 +42,5 @@ class TrueClass
   #
   #     or
   #
-  def |: (boolish obj) -> bool
+  def |: (untyped obj) -> true
 end

data/lib/rbs.rb

@@ -44,6 +44,7 @@ require "rbs/factory"
 require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
+require "rbs/type_alias_dependency"
 
 begin
   require "rbs/parser"

data/lib/rbs/cli.rb

@@ -451,6 +451,7 @@ EOU
         builder.expand_alias(name).tap do |type|
           validator.validate_type type, context: [Namespace.root]
         end
+        validator.validate_type_alias(entry: decl)
       end
     end
 

data/lib/rbs/errors.rb

@@ -386,4 +386,20 @@ module RBS
       end
     end
   end
+
+  class RecursiveTypeAliasError < LoadingError
+    attr_reader :alias_names
+    attr_reader :location
+
+    def initialize(alias_names:, location:)
+      @alias_names = alias_names
+      @location = location
+
+      super "#{Location.to_string location}: Recursive type alias definition found for: #{name}"
+    end
+
+    def name
+      @alias_names.map(&:name).join(', ')
+    end
+  end
 end

data/lib/rbs/parser.rb

@@ -326,7 +326,7 @@ def next_token
     new_token(:tUKEYWORD, input.matched.chop.to_sym)
   when input.scan(/[A-Z]\w*[?!]:/)
     new_token(:tUKEYWORD_Q_E, input.matched.chop.to_sym)
-  when input.scan(/\$[A-Za-z_]\w*/)
+  when input.scan(/\$([A-Za-z_]\w*|[~*$?!@\/\\;,.=:<>"&`'+]|\d+|-[0-9_A-Za-z])/)
     new_token(:tGLOBALIDENT)
   when input.scan(/@[a-zA-Z_]\w*/)
     new_token(:tIVAR, input.matched.to_sym)

data/lib/rbs/parser.y

@@ -1708,7 +1708,7 @@ def next_token
     new_token(:tUKEYWORD, input.matched.chop.to_sym)
   when input.scan(/[A-Z]\w*[?!]:/)
     new_token(:tUKEYWORD_Q_E, input.matched.chop.to_sym)
-  when input.scan(/\$[A-Za-z_]\w*/)
+  when input.scan(/\$([A-Za-z_]\w*|[~*$?!@\/\\;,.=:<>"&`'+]|\d+|-[0-9_A-Za-z])/)
     new_token(:tGLOBALIDENT)
   when input.scan(/@[a-zA-Z_]\w*/)
     new_token(:tIVAR, input.matched.to_sym)

data/lib/rbs/prototype/rb.rb

@@ -319,9 +319,16 @@ module RBS
                          const_to_name(node.children[0])
                        end
 
+          value_node = node.children.last
+          type = if value_node.nil?
+                  # Give up type prediction when node is MASGN.
+                  Types::Bases::Any.new(location: nil)
+                else
+                  node_type(value_node)
+                end
           decls << AST::Declarations::Constant.new(
             name: const_name,
-            type: node_type(node.children.last),
+            type: type,
             location: nil,
             comment: comments[node.first_lineno - 1]
           )

data/lib/rbs/prototype/runtime.rb

@@ -87,7 +87,7 @@ module RBS
             unless const_name(mix)
               RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
             else
-              module_name = module_full_name = to_type_name(const_name(mix))
+              module_name = module_full_name = to_type_name(const_name(mix), full_name: true)
               if module_full_name.namespace == type_name.namespace
                 module_name = TypeName.new(name: module_full_name.name, namespace: Namespace.empty)
               end

data/lib/rbs/type_alias_dependency.rb

@@ -0,0 +1,88 @@
+module RBS
+  class TypeAliasDependency
+    attr_reader :env
+
+    # Direct dependencies corresponds to a directed graph
+    # with vertices as types and directions based on assignment of types
+    attr_reader :direct_dependencies
+    # A hash which stores the transitive closure
+    # of the directed graph
+    attr_reader :dependencies
+
+    def initialize(env:)
+      @env = env
+    end
+
+    # Check if an alias type definition is circular & prohibited
+    def circular_definition?(alias_name)
+      # Construct transitive closure, if not constructed already
+      transitive_closure() unless @dependencies
+
+      # Check for recursive type alias
+      @dependencies[alias_name][alias_name]
+    end
+
+    def build_dependencies
+      return if @direct_dependencies
+
+      # Initialize hash(a directed graph)
+      @direct_dependencies = {}
+      # Initialize dependencies as an empty hash
+      @dependencies = {}
+      # Iterate over alias declarations inserted into environment
+      env.alias_decls.each do |name, entry|
+        # Construct a directed graph by recursively extracting type aliases
+        @direct_dependencies[name] = direct_dependency(entry.decl.type)
+        # Initialize dependencies with an empty hash
+        @dependencies[name] = {}
+      end
+    end
+
+    def transitive_closure
+      # Construct a graph of direct dependencies
+      build_dependencies()
+      # Construct transitive closure by using DFS(recursive technique)
+      @direct_dependencies.each_key do |name|
+        dependency(name, name)
+      end
+    end
+
+    private
+
+    # Constructs directed graph recursively
+    def direct_dependency(type, result = Set[])
+      case type
+      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Optional
+        # Iterate over nested types & extract type aliases recursively
+        type.each_type do |nested_type|
+          direct_dependency(nested_type, result)
+        end
+      when RBS::Types::Alias
+        # Append type name if the type is an alias
+        result << type.name
+      end
+
+      result
+    end
+
+    # Recursive function to construct transitive closure
+    def dependency(start, vertex, nested = nil)
+      if (start == vertex)
+        if (@direct_dependencies[start].include?(vertex) || nested)
+          # Mark a vertex as connected to itself
+          # if it is connected as an edge || a path(traverse multiple edges)
+          @dependencies[start][vertex] = true
+        end
+      else
+        # Mark a pair of vertices as connected while recursively performing DFS
+        @dependencies[start][vertex] = true
+      end
+
+      # Iterate over the direct dependencies of the vertex
+      @direct_dependencies[vertex]&.each do |type_name|
+        # Invoke the function unless it is already checked
+        dependency(start, type_name, start == type_name) unless @dependencies[start][type_name]
+      end
+    end
+  end
+end

data/lib/rbs/validator.rb

@@ -53,5 +53,10 @@ module RBS
         validate_type(type, context: context)
       end
     end
+
+    def validate_type_alias(entry:)
+      @type_alias_dependency ||= TypeAliasDependency.new(env: env)
+      raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: entry.decl.location) if @type_alias_dependency.circular_definition?(entry.decl.name)
+    end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.3.2"
+  VERSION = "1.5.1"
 end

data/sig/errors.rbs

@@ -196,4 +196,13 @@ module RBS
 
     def mixin_name: () -> String
   end
+
+  class RecursiveTypeAliasError < LoadingError
+    attr_reader alias_names: Array[TypeName]
+    attr_reader location: Location
+
+    def initialize: (alias_names: Array[TypeName], location: Location) -> void
+
+    def name: () -> String
+  end
 end

data/sig/type_alias_dependency.rbs

@@ -0,0 +1,22 @@
+module RBS
+  class TypeAliasDependency
+    attr_reader env: Environment
+
+    attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
+    attr_reader dependencies: Hash[TypeName, Hash[TypeName, bool]]
+
+    def initialize: (env: Environment) -> void
+
+    def circular_definition?: (TypeName alias_name) -> bool
+
+    def build_dependencies: () -> void
+
+    def transitive_closure: () -> void
+
+    private
+
+    def direct_dependency: (Types::t `type`, ?Set[TypeName] result) -> Set[TypeName]
+
+    def dependency: (TypeName start, TypeName vertex, ?boolish nested) -> void
+  end
+end

data/sig/validator.rbs

@@ -8,5 +8,7 @@ module RBS
     def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
 
     def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+
+    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) -> void
   end
 end

data/stdlib/digest/0/digest.rbs

@@ -0,0 +1,418 @@
+# This module provides a framework for message digest libraries.
+#
+# You may want to look at OpenSSL::Digest as it supports more algorithms.
+#
+# A cryptographic hash function is a procedure that takes data and returns a
+# fixed bit string: the hash value, also known as *digest*. Hash functions are
+# also called one-way functions, it is easy to compute a digest from a message,
+# but it is infeasible to generate a message from a digest.
+#
+# ## Examples
+#
+#     require 'digest'
+#
+#     # Compute a complete digest
+#     Digest::SHA256.digest 'message'       #=> "\xABS\n\x13\xE4Y..."
+#
+#     sha256 = Digest::SHA256.new
+#     sha256.digest 'message'               #=> "\xABS\n\x13\xE4Y..."
+#
+#     # Other encoding formats
+#     Digest::SHA256.hexdigest 'message'    #=> "ab530a13e459..."
+#     Digest::SHA256.base64digest 'message' #=> "q1MKE+RZFJgr..."
+#
+#     # Compute digest by chunks
+#     md5 = Digest::MD5.new
+#     md5.update 'message1'
+#     md5 << 'message2'                     # << is an alias for update
+#
+#     md5.hexdigest                         #=> "94af09c09bb9..."
+#
+#     # Compute digest for a file
+#     sha256 = Digest::SHA256.file 'testfile'
+#     sha256.hexdigest
+#
+# Additionally digests can be encoded in "bubble babble" format as a sequence of
+# consonants and vowels which is more recognizable and comparable than a
+# hexadecimal digest.
+#
+#     require 'digest/bubblebabble'
+#
+#     Digest::SHA256.bubblebabble 'message' #=> "xopoh-fedac-fenyh-..."
+#
+# See the bubble babble specification at
+# http://web.mit.edu/kenta/www/one/bubblebabble/spec/jrtrjwzi/draft-huima-01.txt
+# .
+#
+# ## Digest algorithms
+#
+# Different digest algorithms (or hash functions) are available:
+#
+# MD5
+# :   See RFC 1321 The MD5 Message-Digest Algorithm
+# RIPEMD-160
+# :   As Digest::RMD160. See
+#     http://homes.esat.kuleuven.be/~bosselae/ripemd160.html.
+# SHA1
+# :   See FIPS 180 Secure Hash Standard.
+# SHA2 family
+# :   See FIPS 180 Secure Hash Standard which defines the following algorithms:
+#     *   SHA512
+#     *   SHA384
+#     *   SHA256
+#
+#
+#
+# The latest versions of the FIPS publications can be found here:
+# http://csrc.nist.gov/publications/PubsFIPS.html.
+module Digest
+  # Returns a BubbleBabble encoded version of a given *string*.
+  #
+  def self.bubblebabble: (String) -> String
+
+  def self.const_missing: (Symbol name) -> singleton(::Digest::Base)
+
+  # Generates a hex-encoded version of a given *string*.
+  #
+  def self.hexencode: (String) -> String
+
+  private
+
+  def bubblebabble: (String) -> String
+
+  def hexencode: (String) -> String
+end
+
+# A mutex for Digest().
+Digest::REQUIRE_MUTEX: Thread::Mutex
+
+# This module provides instance methods for a digest implementation object to
+# calculate message digest values.
+module Digest::Instance
+  public
+
+  # Updates the digest using a given *string* and returns self.
+  #
+  # The update() method and the left-shift operator are overridden by each
+  # implementation subclass. (One should be an alias for the other)
+  #
+  def <<: (String) -> self
+
+  # If a string is given, checks whether it is equal to the hex-encoded hash value
+  # of the digest object.  If another digest instance is given, checks whether
+  # they have the same hash value.  Otherwise returns false.
+  #
+  def ==: (::Digest::Instance | String) -> bool
+
+  # If none is given, returns the resulting hash value of the digest in a base64
+  # encoded form, keeping the digest's state.
+  #
+  # If a `string` is given, returns the hash value for the given `string` in a
+  # base64 encoded form, resetting the digest to the initial state before and
+  # after the process.
+  #
+  # In either case, the return value is properly padded with '=' and contains no
+  # line feeds.
+  #
+  def base64digest: (?String? str) -> String
+
+  # Returns the resulting hash value and resets the digest to the initial state.
+  #
+  def base64digest!: () -> String
+
+  # Returns the block length of the digest.
+  #
+  # This method is overridden by each implementation subclass.
+  #
+  def block_length: () -> Integer
+
+  # Returns the resulting hash value in a Bubblebabble encoded form.
+  #
+  def bubblebabble: () -> String
+
+  # If none is given, returns the resulting hash value of the digest, keeping the
+  # digest's state.
+  #
+  # If a *string* is given, returns the hash value for the given *string*,
+  # resetting the digest to the initial state before and after the process.
+  #
+  def digest: (?String) -> String
+
+  # Returns the resulting hash value and resets the digest to the initial state.
+  #
+  def digest!: () -> String
+
+  # Returns the length of the hash value of the digest.
+  #
+  # This method should be overridden by each implementation subclass. If not,
+  # digest_obj.digest().length() is returned.
+  #
+  def digest_length: () -> Integer
+
+  # Updates the digest with the contents of a given file *name* and returns self.
+  #
+  def file: (String name) -> self
+
+  # If none is given, returns the resulting hash value of the digest in a
+  # hex-encoded form, keeping the digest's state.
+  #
+  # If a *string* is given, returns the hash value for the given *string* in a
+  # hex-encoded form, resetting the digest to the initial state before and after
+  # the process.
+  #
+  def hexdigest: (?String) -> String
+
+  # Returns the resulting hash value in a hex-encoded form and resets the digest
+  # to the initial state.
+  #
+  def hexdigest!: () -> String
+
+  # Creates a printable version of the digest object.
+  #
+  def inspect: () -> String
+
+  # Returns digest_obj.digest_length().
+  #
+  def length: () -> Integer
+
+  # Returns a new, initialized copy of the digest object.  Equivalent to
+  # digest_obj.clone().reset().
+  #
+  def new: () -> ::Digest::Base
+
+  # Resets the digest to the initial state and returns self.
+  #
+  # This method is overridden by each implementation subclass.
+  #
+  def reset: () -> self
+
+  # Returns digest_obj.digest_length().
+  #
+  def size: () -> Integer
+
+  # Returns digest_obj.hexdigest().
+  #
+  def to_s: () -> String
+
+  # Updates the digest using a given *string* and returns self.
+  #
+  # The update() method and the left-shift operator are overridden by each
+  # implementation subclass. (One should be an alias for the other)
+  #
+  def update: (String) -> self
+
+  private
+
+  # Finishes the digest and returns the resulting hash value.
+  #
+  # This method is overridden by each implementation subclass and often made
+  # private, because some of those subclasses may leave internal data
+  # uninitialized.  Do not call this method from outside.  Use #digest!() instead,
+  # which ensures that internal data be reset for security reasons.
+  #
+  def finish: () -> self
+end
+
+# This module stands as a base class for digest implementation classes.
+class Digest::Class
+  include ::Digest::Instance
+
+  # Returns the base64 encoded hash value of a given *string*.  The return value
+  # is properly padded with '=' and contains no line feeds.
+  #
+  def self.base64digest: (String str, *untyped) -> String
+
+  # Returns the BubbleBabble encoded hash value of a given *string*.
+  #
+  def self.bubblebabble: (String, *untyped) -> String
+
+  # Returns the hash value of a given *string*.  This is equivalent to
+  # Digest::Class.new(*parameters).digest(string), where extra *parameters*, if
+  # any, are passed through to the constructor and the *string* is passed to
+  # #digest().
+  #
+  def self.digest: (String, *untyped) -> String
+
+  # Creates a digest object and reads a given file, *name*. Optional arguments are
+  # passed to the constructor of the digest class.
+  #
+  #     p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+  #     # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+  #
+  def self.file: (String name, *untyped) -> ::Digest::Class
+
+  # Returns the hex-encoded hash value of a given *string*.  This is almost
+  # equivalent to Digest.hexencode(Digest::Class.new(*parameters).digest(string)).
+  #
+  def self.hexdigest: (String, *untyped) -> String
+
+  private
+
+  def initialize: () -> self
+end
+
+# This abstract class provides a common interface to message digest
+# implementation classes written in C.
+#
+# ## Write a Digest subclass in C
+# Digest::Base provides a common interface to message digest classes written in
+# C. These classes must provide a struct of type rb_digest_metadata_t:
+#     typedef int (*rb_digest_hash_init_func_t)(void *);
+#     typedef void (*rb_digest_hash_update_func_t)(void *, unsigned char *, size_t);
+#     typedef int (*rb_digest_hash_finish_func_t)(void *, unsigned char *);
+#
+#     typedef struct {
+#       int api_version;
+#       size_t digest_len;
+#       size_t block_len;
+#       size_t ctx_size;
+#       rb_digest_hash_init_func_t init_func;
+#       rb_digest_hash_update_func_t update_func;
+#       rb_digest_hash_finish_func_t finish_func;
+#     } rb_digest_metadata_t;
+#
+# This structure must be set as an instance variable named `metadata` (without
+# the +@+ in front of the name). By example:
+#      static const rb_digest_metadata_t sha1 = {
+#         RUBY_DIGEST_API_VERSION,
+#         SHA1_DIGEST_LENGTH,
+#         SHA1_BLOCK_LENGTH,
+#         sizeof(SHA1_CTX),
+#         (rb_digest_hash_init_func_t)SHA1_Init,
+#         (rb_digest_hash_update_func_t)SHA1_Update,
+#         (rb_digest_hash_finish_func_t)SHA1_Finish,
+#     };
+#
+#     rb_ivar_set(cDigest_SHA1, rb_intern("metadata"),
+#                 Data_Wrap_Struct(0, 0, 0, (void *)&sha1));
+class Digest::Base < Digest::Class
+  public
+
+  # Update the digest using given *string* and return `self`.
+  #
+  def <<: (String) -> self
+
+  # Return the block length of the digest in bytes.
+  #
+  def block_length: () -> Integer
+
+  # Return the length of the hash value in bytes.
+  #
+  def digest_length: () -> Integer
+
+  # Reset the digest to its initial state and return `self`.
+  #
+  def reset: () -> self
+
+  # Update the digest using given *string* and return `self`.
+  #
+  def update: (String) -> self
+
+  private
+
+  def finish: () -> String
+
+  def initialize_copy: (::Digest::Base) -> self
+end
+
+# A class for calculating message digests using the SHA-1 Secure Hash Algorithm
+# by NIST (the US' National Institute of Standards and Technology), described in
+# FIPS PUB 180-1.
+#
+# See Digest::Instance for digest API.
+#
+# SHA-1 calculates a digest of 160 bits (20 bytes).
+#
+# ## Examples
+#     require 'digest'
+#
+#     # Compute a complete digest
+#     Digest::SHA1.hexdigest 'abc'      #=> "a9993e36..."
+#
+#     # Compute digest by chunks
+#     sha1 = Digest::SHA1.new               # =>#<Digest::SHA1>
+#     sha1.update "ab"
+#     sha1 << "c"                           # alias for #update
+#     sha1.hexdigest                        # => "a9993e36..."
+#
+#     # Use the same object to compute another digest
+#     sha1.reset
+#     sha1 << "message"
+#     sha1.hexdigest                        # => "6f9b9af3..."
+class Digest::SHA1 < Digest::Base
+end
+
+# A class for calculating message digests using the MD5 Message-Digest Algorithm
+# by RSA Data Security, Inc., described in RFC1321.
+#
+# MD5 calculates a digest of 128 bits (16 bytes).
+#
+# ## Examples
+#     require 'digest'
+#
+#     # Compute a complete digest
+#     Digest::MD5.hexdigest 'abc'      #=> "90015098..."
+#
+#     # Compute digest by chunks
+#     md5 = Digest::MD5.new               # =>#<Digest::MD5>
+#     md5.update "ab"
+#     md5 << "c"                           # alias for #update
+#     md5.hexdigest                        # => "90015098..."
+#
+#     # Use the same object to compute another digest
+#     md5.reset
+#     md5 << "message"
+#     md5.hexdigest                        # => "78e73102..."
+class Digest::MD5 < Digest::Base
+end
+
+# A class for calculating message digests using RIPEMD-160 cryptographic hash
+# function, designed by Hans Dobbertin, Antoon Bosselaers, and Bart Preneel.
+#
+# RMD160 calculates a digest of 160 bits (20 bytes).
+#
+# ## Examples
+#     require 'digest'
+#
+#     # Compute a complete digest
+#     Digest::RMD160.hexdigest 'abc'      #=> "8eb208f7..."
+#
+#     # Compute digest by chunks
+#     rmd160 = Digest::RMD160.new               # =>#<Digest::RMD160>
+#     rmd160.update "ab"
+#     rmd160 << "c"                           # alias for #update
+#     rmd160.hexdigest                        # => "8eb208f7..."
+#
+#     # Use the same object to compute another digest
+#     rmd160.reset
+#     rmd160 << "message"
+#     rmd160.hexdigest                        # => "1dddbe1b..."
+class Digest::RMD160 < Digest::Base
+end
+
+class Digest::SHA256 < Digest::Base
+end
+
+class Digest::SHA384 < Digest::Base
+end
+
+class Digest::SHA512 < Digest::Base
+end
+
+class Object
+  # Returns a Digest subclass by `name` in a thread-safe manner even when
+  # on-demand loading is involved.
+  #
+  #     require 'digest'
+  #
+  #     Digest("MD5")
+  #     # => Digest::MD5
+  #
+  #     Digest(:SHA256)
+  #     # => Digest::SHA256
+  #
+  #     Digest(:Foo)
+  #     # => LoadError: library not found for class Digest::Foo -- digest/foo
+  #
+  def Digest: (String | Symbol name) -> singleton(::Digest::Base)
+end