rbs 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f458be96f0cfc3e45e51bb77f4d42aafba7f1fee62e0ed8695eb6a95b85189b2
-  data.tar.gz: 9b84c8860182155f4e5979e668a953d1b8191754f01c6443d549fc14b5be1908
+  metadata.gz: 809717411a8c5922fa704c952333218bfb14ab4eef9e162c26d5d905de9009a2
+  data.tar.gz: 93d8af500d84269a6ea5d5631538de69d01633276a0860002c7bd63e3ae05ace
 SHA512:
-  metadata.gz: f0c7616abdb3a3d4e08212014aebad858e113acf265641e4f657b2d48b9e20ec8ac7744a18f90459086be39953eb7ebef9d32acd3b22362e31d6e12e83251baf
-  data.tar.gz: ee12553e0611d2b8826d9687ab63fcc38bfb67435bcf537950b31ef6070c26d85fcf8d956ccc1285072e6513facdbd43521935ae9372a11cae6f100e16691084
+  metadata.gz: b8109ce0129574ed1752291a4c541d99c2738bb238d16bf1bd153123181386eb461075a3ecb68502191bdadb8d09b1501b68aa2f45fc39cbac7febbed13f28b2
+  data.tar.gz: cbeca49f8e35b2ecf9ac32a11b7389c30da90418594e840ee50c2cf276470d37eee0d2d615169fed5b0c89daf00216d4e5c78d5ff310e455729fbe435e917bf3

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.18.0 (2020-12-01)
+
+* Signature updates for `YAML`, `ObjectSpace`, and `Singleton` ([#408](https://github.com/ruby/rbs/pull/408), [#477](https://github.com/ruby/rbs/pull/477), [#482](https://github.com/ruby/rbs/pull/482))
+* `prototype rb` improvements ([#492](https://github.com/ruby/rbs/pull/492), [#487](https://github.com/ruby/rbs/pull/487), [#486](https://github.com/ruby/rbs/pull/486), [#481](https://github.com/ruby/rbs/pull/481))
+* Runtime type checker improvements ([#488](https://github.com/ruby/rbs/pull/488), [#489](https://github.com/ruby/rbs/pull/489), [#490](https://github.com/ruby/rbs/pull/490))
+* Update `DependencyWalker` API to receive _Node_ objects instead of `TypeName` ([#484](https://github.com/ruby/rbs/pull/484))
+* Assume encoding of RBS files to be UTF-8 ([#493](https://github.com/ruby/rbs/pull/493))
+
 ## 0.17.0 (2020-11-14)
 
 * Signature updates for `Enumerable`, `Hash`, and `TSort` ([#462](https://github.com/ruby/rbs/pull/462), [#468](https://github.com/ruby/rbs/pull/468), [#471](https://github.com/ruby/rbs/pull/471), [#472](https://github.com/ruby/rbs/pull/472), [#473](https://github.com/ruby/rbs/pull/473), [#474](https://github.com/ruby/rbs/pull/474))

data/Rakefile

@@ -36,6 +36,11 @@ task :validate => :parser do
       lib << "bigdecimal"
     end
 
+    if lib == ["yaml"]
+      lib << "dbm"
+      lib << "pstore"
+    end
+
     sh "#{ruby} #{rbs} #{lib.map {|l| "-r #{l}"}.join(" ")} validate --silent"
   end
 end

data/core/object_space.rbs

@@ -0,0 +1,98 @@
+# The ObjectSpace module contains a number of routines that interact with the
+# garbage collection facility and allow you to traverse all living objects with
+# an iterator.
+#
+# ObjectSpace also provides support for object finalizers, procs that will be
+# called when a specific object is about to be destroyed by garbage collection.
+#
+#     require 'objspace'
+#
+#     a = "A"
+#     b = "B"
+#
+#     ObjectSpace.define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
+#     ObjectSpace.define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
+#
+# *produces:*
+#
+#     Finalizer two on 537763470
+#     Finalizer one on 537763480
+module ObjectSpace
+  def self._id2ref: (Integer id) -> untyped
+
+  # Counts all objects grouped by type.
+  #
+  # It returns a hash, such as:
+  #     {
+  #       :TOTAL=>10000,
+  #       :FREE=>3011,
+  #       :T_OBJECT=>6,
+  #       :T_CLASS=>404,
+  #       # ...
+  #     }
+  #
+  # The contents of the returned hash are implementation specific. It may be
+  # changed in future.
+  #
+  # The keys starting with `:T_` means live objects. For example, `:T_ARRAY` is
+  # the number of arrays. `:FREE` means object slots which is not used now.
+  # `:TOTAL` means sum of above.
+  #
+  # If the optional argument `result_hash` is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  #     h = {}
+  #     ObjectSpace.count_objects(h)
+  #     puts h
+  #     # => { :TOTAL=>10000, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249 }
+  #
+  # This method is only expected to work on C Ruby.
+  #
+  def self.count_objects: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Adds *aProc* as a finalizer, to be called after *obj* was destroyed. The
+  # object ID of the *obj* will be passed as an argument to *aProc*. If *aProc* is
+  # a lambda or method, make sure it can be called with a single argument.
+  #
+  def self.define_finalizer: (untyped obj, ^(Integer id) -> void aProc) -> [ Integer, Proc ]
+                           | (untyped obj) { (Integer id) -> void } -> [ Integer, Proc ]
+
+  # Calls the block once for each living, nonimmediate object in this Ruby
+  # process. If *module* is specified, calls the block for only those classes or
+  # modules that match (or are a subclass of) *module*. Returns the number of
+  # objects found. Immediate objects (`Fixnum`s, `Symbol`s `true`, `false`, and
+  # `nil`) are never returned. In the example below, #each_object returns both the
+  # numbers we defined and several constants defined in the Math module.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     a = 102.7
+  #     b = 95       # Won't be returned
+  #     c = 12345678987654321
+  #     count = ObjectSpace.each_object(Numeric) {|x| p x }
+  #     puts "Total count: #{count}"
+  #
+  # *produces:*
+  #
+  #     12345678987654321
+  #     102.7
+  #     2.71828182845905
+  #     3.14159265358979
+  #     2.22044604925031e-16
+  #     1.7976931348623157e+308
+  #     2.2250738585072e-308
+  #     Total count: 7
+  #
+  def self.each_object: (?Module `module`) -> Enumerator[untyped, Integer]
+                      | (?Module `module`) { (untyped obj) -> void } -> Integer
+
+  def self.garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool) -> void
+
+  # Removes all finalizers for *obj*.
+  #
+  def self.undefine_finalizer: [X] (X obj) -> X
+
+  private
+
+  def garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool) -> void
+end

data/lib/rbs/environment_loader.rb

@@ -118,7 +118,7 @@ module RBS
           next if files.include?(path)
 
           files << path
-          buffer = Buffer.new(name: path.to_s, content: path.read)
+          buffer = Buffer.new(name: path.to_s, content: path.read(encoding: "UTF-8"))
 
           Parser.parse_signature(buffer).each do |decl|
             yield decl, buffer, source, path

data/lib/rbs/environment_walker.rb

@@ -1,5 +1,9 @@
 module RBS
   class EnvironmentWalker
+    InstanceNode = Struct.new(:type_name, keyword_init: true)
+    SingletonNode = Struct.new(:type_name, keyword_init: true)
+    TypeNameNode = Struct.new(:type_name, keyword_init: true)
+
     attr_reader :env
 
     def initialize(env:)
@@ -23,50 +27,70 @@ module RBS
     include TSort
 
     def tsort_each_node(&block)
-      env.class_decls.each_key(&block)
-      env.interface_decls.each_key(&block)
-      env.alias_decls.each_key(&block)
+      env.class_decls.each_key do |type_name|
+        yield InstanceNode.new(type_name: type_name)
+        yield SingletonNode.new(type_name: type_name)
+      end
+      env.interface_decls.each_key do |type_name|
+        yield TypeNameNode.new(type_name: type_name)
+      end
+      env.alias_decls.each_key do |type_name|
+        yield TypeNameNode.new(type_name: type_name)
+      end
     end
 
-    def tsort_each_child(name, &block)
+    def tsort_each_child(node, &block)
+      name = node.type_name
+
       unless name.namespace.empty?
-        yield name.namespace.to_type_name
+        yield SingletonNode.new(type_name: name.namespace.to_type_name)
       end
 
-      case
-      when name.class?, name.interface?
-        definitions = []
-
+      case node
+      when TypeNameNode
         case
-        when name.class?
-          definitions << builder.build_instance(name)
-          definitions << builder.build_singleton(name)
         when name.interface?
-          definitions << builder.build_interface(name)
+          definition = builder.build_interface(name)
+          unless only_ancestors?
+            definition.each_type do |type|
+              each_type_name type, &block
+            end
+          end
+        when name.alias?
+          each_type_name builder.expand_alias(name), &block
+        else
+          raise "Unexpected TypeNameNode with type_name=#{name}"
         end
 
-        definitions.each do |definition|
-          if ancestors = definition.ancestors
-            ancestors.ancestors.each do |ancestor|
-              yield ancestor.name
+      when InstanceNode, SingletonNode
+        definition = if node.is_a?(InstanceNode)
+                       builder.build_instance(name)
+                     else
+                       builder.build_singleton(name)
+                     end
+
+        if ancestors = definition.ancestors
+          ancestors.ancestors.each do |ancestor|
+            case ancestor
+            when Definition::Ancestor::Instance
+              yield InstanceNode.new(type_name: ancestor.name)
 
-              case ancestor
-              when Definition::Ancestor::Instance
+              unless only_ancestors?
                 ancestor.args.each do |type|
                   each_type_name type, &block
                 end
               end
+            when Definition::Ancestor::Singleton
+              yield SingletonNode.new(type_name: ancestor.name)
             end
           end
+        end
 
-          unless only_ancestors?
-            definition.each_type do |type|
-              each_type_name type, &block
-            end
+        unless only_ancestors?
+          definition.each_type do |type|
+            each_type_name type, &block
           end
         end
-      when name.alias?
-        each_type_name builder.expand_alias(name), &block
       end
     end
 
@@ -83,14 +107,19 @@ module RBS
       when RBS::Types::Bases::Nil
       when RBS::Types::Variable
       when RBS::Types::ClassSingleton
-        yield type.name
-      when RBS::Types::ClassInstance, RBS::Types::Interface
-        yield type.name
+        yield SingletonNode.new(type_name: type.name)
+      when RBS::Types::ClassInstance
+        yield InstanceNode.new(type_name: type.name)
+        type.args.each do |ty|
+          each_type_name(ty, &block)
+        end
+      when RBS::Types::Interface
+        yield TypeNameNode.new(type_name: type.name)
         type.args.each do |ty|
           each_type_name(ty, &block)
         end
       when RBS::Types::Alias
-        yield type.name
+        yield TypeNameNode.new(type_name: type.name)
       when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
         type.types.each do |ty|
           each_type_name ty, &block

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,22 @@
 module RBS
   module Prototype
     class RB
+      Context = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+        def self.initial(namespace: Namespace.root)
+          self.new(module_function: false, singleton: false, namespace: namespace)
+        end
+
+        def method_kind
+          if singleton
+            :singleton
+          elsif module_function
+            :singleton_instance
+          else
+            :instance
+          end
+        end
+      end
+
       attr_reader :source_decls
       attr_reader :toplevel_members
 
@@ -52,10 +68,10 @@ module RBS
           end
         end
 
-        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, singleton: false
+        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, context: Context.initial
       end
 
-      def process(node, decls:, comments:, singleton:)
+      def process(node, decls:, comments:, context:)
         case node.type
         when :CLASS
           class_name, super_class, *class_body = node.children
@@ -71,9 +87,11 @@ module RBS
 
           decls.push kls
 
+          new_ctx = Context.initial(namespace: context.namespace + kls.name.to_namespace)
           each_node class_body do |child|
-            process child, decls: kls.members, comments: comments, singleton: false
+            process child, decls: kls.members, comments: comments, context: new_ctx
           end
+          remove_unnecessary_accessibility_methods! kls.members
 
         when :MODULE
           module_name, *module_body = node.children
@@ -90,9 +108,11 @@ module RBS
 
           decls.push mod
 
+          new_ctx = Context.initial(namespace: context.namespace + mod.name.to_namespace)
           each_node module_body do |child|
-            process child, decls: mod.members, comments: comments, singleton: false
+            process child, decls: mod.members, comments: comments, context: new_ctx
           end
+          remove_unnecessary_accessibility_methods! mod.members
 
         when :SCLASS
           this, body = node.children
@@ -101,14 +121,13 @@ module RBS
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
-          each_child(body) do |child|
-            process child, decls: decls, comments: comments, singleton: true
-          end
+          ctx = Context.initial.tap { |ctx| ctx.singleton = true }
+          process_children(body, decls: decls, comments: comments, context: ctx)
 
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
-              kind = singleton ? :singleton : :instance
+              kind = context.method_kind
             else
               _, def_name, def_body = node.children
               kind = :singleton
@@ -140,14 +159,14 @@ module RBS
           member = AST::Members::Alias.new(
             new_name: new_name,
             old_name: old_name,
-            kind: singleton ? :singleton : :instance,
+            kind: context.singleton ? :singleton : :instance,
             annotations: [],
             location: nil,
             comment: comments[node.first_lineno - 1],
           )
           decls.push member unless decls.include?(member)
 
-        when :FCALL
+        when :FCALL, :VCALL
           # Inside method definition cannot reach here.
           args = node.children[1]&.children || []
 
@@ -166,7 +185,7 @@ module RBS
             end
           when :extend
             args.each do |arg|
-              if (name = const_to_name(arg))
+              if (name = const_to_name(arg, context: context))
                 decls << AST::Members::Extend.new(
                   name: name,
                   args: [],
@@ -220,16 +239,61 @@ module RBS
               decls << AST::Members::Alias.new(
                 new_name: new_name,
                 old_name: old_name,
-                kind: singleton ? :singleton : :instance,
+                kind: context.singleton ? :singleton : :instance,
                 annotations: [],
                 location: nil,
                 comment: comments[node.first_lineno - 1],
               )
             end
+          when :module_function
+            if args.empty?
+              context.module_function = true
+            else
+              module_func_context = context.dup.tap { |ctx| ctx.module_function = true }
+              args.each do |arg|
+                if arg && (name = literal_to_symbol(arg))
+                  if i = find_def_index_by_name(decls, name)
+                    decls[i] = decls[i].update(kind: :singleton_instance)
+                  end
+                elsif arg
+                  process arg, decls: decls, comments: comments, context: module_func_context
+                end
+              end
+            end
+          when :public, :private
+            accessibility = __send__(node.children[0])
+            if args.empty?
+              decls << accessibility
+            else
+              args.each do |arg|
+                if arg && (name = literal_to_symbol(arg))
+                  if i = find_def_index_by_name(decls, name)
+                    current = current_accessibility(decls, i)
+                    if current != accessibility
+                      decls.insert(i + 1, current)
+                      decls.insert(i, accessibility)
+                    end
+                  end
+                end
+              end
+
+              # For `private def foo` syntax
+              current = current_accessibility(decls)
+              decls << accessibility
+              process_children(node, decls: decls, comments: comments, context: context)
+              decls << current
+            end
+          else
+            process_children(node, decls: decls, comments: comments, context: context)
           end
 
-          each_child node do |child|
-            process child, decls: decls, comments: comments, singleton: singleton
+        when :ITER
+          method_name = node.children.first.children.first
+          case method_name
+          when :refine
+            # ignore
+          else
+            process_children(node, decls: decls, comments: comments, context: context)
           end
 
         when :CDECL
@@ -248,13 +312,17 @@ module RBS
           )
 
         else
-          each_child node do |child|
-            process child, decls: decls, comments: comments, singleton: singleton
-          end
+          process_children(node, decls: decls, comments: comments, context: context)
+        end
+      end
+
+      def process_children(node, decls:, comments:, context:)
+        each_child node do |child|
+          process child, decls: decls, comments: comments, context: context
         end
       end
 
-      def const_to_name(node)
+      def const_to_name(node, context: nil)
         case node&.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
@@ -268,6 +336,8 @@ module RBS
           TypeName.new(name: node.children[1], namespace: namespace)
         when :COLON3
           TypeName.new(name: node.children[0], namespace: Namespace.root)
+        when :SELF
+          context&.then { |c| c.namespace.to_type_name }
         end
       end
 
@@ -586,6 +656,59 @@ module RBS
       def untyped
         @untyped ||= Types::Bases::Any.new(location: nil)
       end
+
+      def private
+        @private ||= AST::Members::Private.new(location: nil)
+      end
+
+      def public
+        @public ||= AST::Members::Public.new(location: nil)
+      end
+
+      def current_accessibility(decls, index = decls.size)
+        idx = decls.slice(0, index).rindex { |decl| decl == private || decl == public }
+        (idx && decls[idx]) || public
+      end
+
+      def remove_unnecessary_accessibility_methods!(decls)
+        current = public
+        idx = 0
+
+        loop do
+          decl = decls[idx] or break
+          if current == decl
+            decls.delete_at(idx)
+            next
+          end
+
+          if 0 < idx && is_accessibility?(decls[idx - 1]) && is_accessibility?(decl)
+            decls.delete_at(idx - 1)
+            idx -= 1
+            current = current_accessibility(decls, idx)
+            next
+          end
+
+          current = decl if is_accessibility?(decl)
+          idx += 1
+        end
+
+        decls.pop while decls.last && is_accessibility?(decls.last)
+      end
+
+      def is_accessibility?(decl)
+        decl == public || decl == private
+      end
+
+      def find_def_index_by_name(decls, name)
+        decls.find_index do |decl|
+          case decl
+          when AST::Members::MethodDefinition, AST::Members::AttrReader
+            decl.name == name
+          when AST::Members::AttrWriter
+            decl.name == :"#{name}="
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/prototype/runtime.rb

@@ -94,6 +94,7 @@ module RBS
             optional_positionals << Types::Function::Param.new(name: name, type: untyped)
           when :rest
             requireds = trailing_positionals
+            name = nil if name == :* # For `def f(...) end` syntax
             rest = Types::Function::Param.new(name: name, type: untyped)
           when :keyreq
             required_keywords[name] = Types::Function::Param.new(name: nil, type: untyped)

data/lib/rbs/test/hook.rb

@@ -27,26 +27,28 @@ module RBS
         :>> => "rshift",
         :~ => "tilda"
       }
-      def self.alias_names(target)
+      def self.alias_names(target, random)
+        suffix = "#{RBS::Test.suffix}_#{random}"
+
         case target
         when *OPERATORS.keys
           name = OPERATORS[target]
           [
-            "#{name}____with__#{Test.suffix}",
-            "#{name}____without__#{Test.suffix}"
+            "#{name}____with__#{suffix}",
+            "#{name}____without__#{suffix}"
           ]
         else
           aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
 
           [
-            "#{aliased_target}__with__#{Test.suffix}#{punctuation}",
-            "#{aliased_target}__without__#{Test.suffix}#{punctuation}"
+            "#{aliased_target}__with__#{suffix}#{punctuation}",
+            "#{aliased_target}__without__#{suffix}#{punctuation}"
           ]
         end
       end
 
-      def self.setup_alias_method_chain(klass, target)
-        with_method, without_method = alias_names(target)
+      def self.setup_alias_method_chain(klass, target, random:)
+        with_method, without_method = alias_names(target, random)
 
         RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
 
@@ -65,12 +67,12 @@ module RBS
         end
       end
 
-      def self.hook_method_source(prefix, method_name, key)
-        with_name, without_name = alias_names(method_name)
+      def self.hook_method_source(prefix, method_name, key, random:)
+        with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args)
+def #{with_name}(*args, &block)
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -78,11 +80,17 @@ def #{with_name}(*args)
     block_calls = []
 
     if block_given?
+      receiver = self
       result = __send__(:"#{without_name}", *args) do |*block_args|
         return_from_block = false
 
         begin
-          block_result = yield(*block_args)
+          block_result = if receiver.equal?(self)
+                           yield(*block_args)
+                         else
+                           instance_exec(*block_args, &block)
+                         end
+
           return_from_block = true
         ensure
           exn = $!
@@ -154,17 +162,19 @@ RUBY
       end
 
       def self.hook_instance_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}#", method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}#", method, key, random: random)
 
         klass.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass, method
+        setup_alias_method_chain klass, method, random: random
       end
 
       def self.hook_singleton_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}.",method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}.",method, key, random: random)
 
         klass.singleton_class.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass.singleton_class, method
+        setup_alias_method_chain klass.singleton_class, method, random: random
       end
     end
   end

data/lib/rbs/test/type_check.rb

@@ -288,7 +288,12 @@ module RBS
           end
         when Types::ClassSingleton
           klass = get_class(type.name) or return false
-          val == klass
+          singleton_class = begin
+                              klass.singleton_class
+                            rescue TypeError
+                              return false
+                            end
+          val.is_a?(singleton_class)
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
           if (definition = builder.build_interface(type.name))

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.17.0"
+  VERSION = "0.18.0"
 end

data/stdlib/singleton/0/singleton.rbs

@@ -0,0 +1,111 @@
+# The Singleton module implements the Singleton pattern.
+#
+# ## Usage
+#
+# To use Singleton, include the module in your class.
+#
+#     class Klass
+#        include Singleton
+#        # ...
+#     end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#     a,b = Klass.instance, Klass.instance
+#
+#     a == b
+#     # => true
+#
+#     Klass.new
+#     # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#     class OtherKlass
+#       include Singleton
+#       # ...
+#     end
+#
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 0
+#
+#     OtherKlass.instance
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 1
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# ## Implementation
+#
+# This above is achieved by:
+#
+# *   Making Klass.new and Klass.allocate private.
+#
+# *   Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#     Singleton properties are kept when inherited and cloned.
+#
+# *   Providing the Klass.instance() method that returns the same object each
+#     time it is called.
+#
+# *   Overriding Klass._load(str) to call Klass.instance().
+#
+# *   Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#     cloning or duping.
+#
+#
+# ## Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables from the
+# instance. Classes using Singleton can provide custom _load(str) and
+# _dump(depth) methods to retain some of the previous state of the instance.
+#
+#     require 'singleton'
+#
+#     class Example
+#       include Singleton
+#       attr_accessor :keep, :strip
+#       def _dump(depth)
+#         # this strips the @strip information from the instance
+#         Marshal.dump(@keep, depth)
+#       end
+#
+#       def self._load(str)
+#         instance.keep = Marshal.load(str)
+#         instance
+#       end
+#     end
+#
+#     a = Example.instance
+#     a.keep = "keep this"
+#     a.strip = "get rid of this"
+#
+#     stored_state = Marshal.dump(a)
+#
+#     a.keep = nil
+#     a.strip = nil
+#     b = Marshal.load(stored_state)
+#     p a == b  #  => true
+#     p a.keep  #  => "keep this"
+#     p a.strip #  => nil
+module Singleton
+  def self.__init__: (Class klass) -> Class
+
+  def self.instance: () -> instance
+
+  public
+
+  # By default, do not retain any state when marshalling.
+  #
+  def _dump: (?Integer depth) -> String
+
+  # Raises a TypeError to prevent cloning.
+  #
+  def clone: () -> bot
+
+  # Raises a TypeError to prevent duping.
+  #
+  def dup: () -> bot
+end
+
+Singleton::VERSION: String

data/stdlib/yaml/0/dbm.rbs

@@ -0,0 +1,221 @@
+# YAML Ain't Markup Language
+#
+# This module provides a Ruby interface for data serialization in YAML format.
+#
+# The YAML module is an alias of Psych, the YAML engine for Ruby.
+#
+# ## Usage
+#
+# Working with YAML can be very simple, for example:
+#
+#     require 'yaml'
+#     # Parse a YAML string
+#     YAML.load("--- foo") #=> "foo"
+#
+#     # Emit some YAML
+#     YAML.dump("foo")     # => "--- foo\n...\n"
+#     { :a => 'b'}.to_yaml  # => "---\n:a: b\n"
+#
+# As the implementation is provided by the Psych library, detailed documentation
+# can be found in that library's docs (also part of standard library).
+#
+# ## Security
+#
+# Do not use YAML to load untrusted data. Doing so is unsafe and could allow
+# malicious input to execute arbitrary code inside your application. Please see
+# doc/security.rdoc for more information.
+#
+# ## History
+#
+# Syck was the original for YAML implementation in Ruby's standard library
+# developed by why the lucky stiff.
+#
+# You can still use Syck, if you prefer, for parsing and emitting YAML, but you
+# must install the 'syck' gem now in order to use it.
+#
+# In older Ruby versions, ie. <= 1.9, Syck is still provided, however it was
+# completely removed with the release of Ruby 2.0.0.
+#
+# ## More info
+#
+# For more advanced details on the implementation see Psych, and also check out
+# http://yaml.org for spec details and other helpful information.
+#
+# Psych is maintained by Aaron Patterson on github:
+# https://github.com/ruby/psych
+#
+# Syck can also be found on github: https://github.com/ruby/syck
+#
+module YAML
+  # YAML + DBM = YDBM
+  #
+  # YAML::DBM provides the same interface as ::DBM.
+  #
+  # However, while DBM only allows strings for both keys and values,
+  # this library allows one to use most Ruby objects for values
+  # by first converting them to YAML. Keys must be strings.
+  #
+  # Conversion to and from YAML is performed automatically.
+  #
+  # See the documentation for ::DBM and ::YAML for more information.
+  class DBM < ::DBM
+    VERSION: ::String
+
+    # :call-seq:
+    #   ydbm[key] -> value
+    #
+    # Return value associated with +key+ from database.
+    #
+    # Returns +nil+ if there is no such +key+.
+    #
+    # See #fetch for more information.
+    def []: (String key) -> untyped
+
+    # :call-seq:
+    #   ydbm[key] = value
+    #
+    # Set +key+ to +value+ in database.
+    #
+    # +value+ will be converted to YAML before storage.
+    #
+    # See #store for more information.
+    def []=: (String key, untyped val) -> untyped
+
+    # :call-seq:
+    #   ydbm.fetch( key, ifnone = nil )
+    #   ydbm.fetch( key ) { |key| ... }
+    #
+    # Return value associated with +key+.
+    #
+    # If there is no value for +key+ and no block is given, returns +ifnone+.
+    #
+    # Otherwise, calls block passing in the given +key+.
+    #
+    # See ::DBM#fetch for more information.
+    def fetch: (String keystr, ?untyped? ifnone) { (untyped) -> untyped } -> untyped
+
+    # Deprecated, used YAML::DBM#key instead.
+    # ----
+    # Note:
+    # YAML::DBM#index makes warning from internal of ::DBM#index.
+    # It says 'DBM#index is deprecated; use DBM#key', but DBM#key
+    # behaves not same as DBM#index.
+    #
+    def index: (String keystr) -> untyped
+
+    # :call-seq:
+    #   ydbm.key(value) -> string
+    #
+    # Returns the key for the specified value.
+    def key: (String keystr) -> String
+
+    # :call-seq:
+    #   ydbm.values_at(*keys)
+    #
+    # Returns an array containing the values associated with the given keys.
+    def values_at: (*untyped keys) -> Array[untyped]
+
+    # :call-seq:
+    #   ydbm.delete(key)
+    #
+    # Deletes value from database associated with +key+.
+    #
+    # Returns value or +nil+.
+    def delete: (String key) -> untyped
+
+    def delete_if: () { (untyped, untyped) -> untyped } -> untyped
+
+    # :call-seq:
+    #   ydbm.reject { |key, value| ... }
+    #
+    # Converts the contents of the database to an in-memory Hash, then calls
+    # Hash#reject with the specified code block, returning a new Hash.
+    def reject: () { (untyped, untyped) -> untyped } -> Hash[untyped, untyped]
+
+    def each_pair: () { (untyped, untyped) -> untyped } -> untyped
+
+    def each_value: () { (untyped) -> untyped } -> untyped
+
+    # :call-seq:
+    #   ydbm.values
+    #
+    # Returns an array of values from the database.
+    def values: () -> untyped
+
+    # :call-seq:
+    #   ydbm.has_value?(value)
+    #
+    # Returns true if specified +value+ is found in the database.
+    def has_value?: (untyped val) -> (::TrueClass | ::FalseClass)
+
+    # :call-seq:
+    #   ydbm.invert -> hash
+    #
+    # Returns a Hash (not a DBM database) created by using each value in the
+    # database as a key, with the corresponding key as its value.
+    #
+    # Note that all values in the hash will be Strings, but the keys will be
+    # actual objects.
+    def invert: () -> Hash[untyped, untyped]
+
+    # :call-seq:
+    #   ydbm.replace(hash) -> ydbm
+    #
+    # Replaces the contents of the database with the contents of the specified
+    # object. Takes any object which implements the each_pair method, including
+    # Hash and DBM objects.
+    def replace: (Hash[untyped, untyped] | DBM hsh) -> YAML::DBM
+
+    # :call-seq:
+    #   ydbm.shift -> [key, value]
+    #
+    # Removes a [key, value] pair from the database, and returns it.
+    # If the database is empty, returns +nil+.
+    #
+    # The order in which values are removed/returned is not guaranteed.
+    def shift: () -> (Array[untyped] | untyped)
+
+    # :call-seq:
+    #   ydbm.select { |key, value| ... }
+    #   ydbm.select(*keys)
+    #
+    # If a block is provided, returns a new array containing [key, value] pairs
+    # for which the block returns true.
+    #
+    # Otherwise, same as #values_at
+    def select: (*untyped keys) { (untyped, untyped) -> untyped } -> Array[untyped]
+
+    # :call-seq:
+    #   ydbm.store(key, value) -> value
+    #
+    # Stores +value+ in database with +key+ as the index. +value+ is converted
+    # to YAML before being stored.
+    #
+    # Returns +value+
+    def store: (String key, untyped val) -> untyped
+
+    # :call-seq:
+    #   ydbm.update(hash) -> ydbm
+    #
+    # Updates the database with multiple values from the specified object.
+    # Takes any object which implements the each_pair method, including
+    # Hash and DBM objects.
+    #
+    # Returns +self+.
+    def update: (Hash[untyped, untyped]) -> YAML::DBM
+
+    # :call-seq:
+    #   ydbm.to_a -> array
+    #
+    # Converts the contents of the database to an array of [key, value] arrays,
+    # and returns it.
+    def to_a: () -> Array [untyped]
+
+    # :call-seq:
+    #   ydbm.to_hash -> hash
+    #
+    # Converts the contents of the database to an in-memory Hash object, and
+    # returns it.
+    def to_hash: () -> Hash[untyped, untyped]
+  end
+end

data/stdlib/yaml/0/store.rbs

@@ -0,0 +1,53 @@
+# YAML::Store provides the same functionality as PStore, except it uses YAML to
+# dump objects instead of Marshal.
+#
+# ## Example
+#
+#     require 'yaml/store'
+#
+#     Person = Struct.new :first_name, :last_name
+#
+#     people = [Person.new("Bob", "Smith"), Person.new("Mary", "Johnson")]
+#
+#     store = YAML::Store.new "test.store"
+#
+#     store.transaction do
+#       store["people"] = people
+#       store["greeting"] = { "hello" => "world" }
+#     end
+#
+# After running the above code, the contents of "test.store" will be:
+#
+#     ---
+#     people:
+#     - !ruby/struct:Person
+#       first_name: Bob
+#       last_name: Smith
+#     - !ruby/struct:Person
+#       first_name: Mary
+#       last_name: Johnson
+#     greeting:
+#       hello: world
+#
+class YAML::Store < ::PStore
+  # Creates a new YAML::Store object, which will store data in `file_name`. If the
+  # file does not already exist, it will be created.
+  #
+  # YAML::Store objects are always reentrant. But if *thread_safe* is set to true,
+  # then it will become thread-safe at the cost of a minor performance hit.
+  #
+  # Options passed in through `yaml_opts` will be used when converting the store
+  # to YAML via Hash#to_yaml().
+  #
+  def initialize: (*untyped o) -> YAML::Store
+
+  def dump: (untyped table) -> String
+
+  def empty_marshal_checksum: () -> String
+
+  def empty_marshal_data: () -> String
+
+  def load: (String) -> untyped
+
+  def marshal_dump_supports_canonical_option?: () -> ::FalseClass
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -74,6 +74,7 @@ files:
 - core/nil_class.rbs
 - core/numeric.rbs
 - core/object.rbs
+- core/object_space.rbs
 - core/proc.rbs
 - core/process.rbs
 - core/random.rbs
@@ -213,6 +214,7 @@ files:
 - stdlib/pty/0/pty.rbs
 - stdlib/securerandom/0/securerandom.rbs
 - stdlib/set/0/set.rbs
+- stdlib/singleton/0/singleton.rbs
 - stdlib/tmpdir/0/tmpdir.rbs
 - stdlib/tsort/0/cyclic.rbs
 - stdlib/tsort/0/interfaces.rbs
@@ -223,6 +225,8 @@ files:
 - stdlib/uri/0/https.rbs
 - stdlib/uri/0/ldap.rbs
 - stdlib/uri/0/ldaps.rbs
+- stdlib/yaml/0/dbm.rbs
+- stdlib/yaml/0/store.rbs
 - stdlib/zlib/0/zlib.rbs
 - steep/Gemfile
 - steep/Gemfile.lock
@@ -249,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.0.rc.2
 signing_key:
 specification_version: 4
 summary: Type signature for Ruby.