rbs 0.17.0 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f458be96f0cfc3e45e51bb77f4d42aafba7f1fee62e0ed8695eb6a95b85189b2
-  data.tar.gz: 9b84c8860182155f4e5979e668a953d1b8191754f01c6443d549fc14b5be1908
+  metadata.gz: 7d0358484cf9cfd6a58aba4115025628e9af481fbeb11079ba189e387486bd85
+  data.tar.gz: 01fa1f2883a0faa043d5116118e6d4bbebb33dc3290d32d9404935817e589643
 SHA512:
-  metadata.gz: f0c7616abdb3a3d4e08212014aebad858e113acf265641e4f657b2d48b9e20ec8ac7744a18f90459086be39953eb7ebef9d32acd3b22362e31d6e12e83251baf
-  data.tar.gz: ee12553e0611d2b8826d9687ab63fcc38bfb67435bcf537950b31ef6070c26d85fcf8d956ccc1285072e6513facdbd43521935ae9372a11cae6f100e16691084
+  metadata.gz: 7a16ce63cf0d28ba0834f7a702767aa5dcb7440a0ef83d00f443e6877977abdb751c6e7816266d45af44cbe21b3eafc7a563edfdf678662a8412f4d8b758d80c
+  data.tar.gz: 45e237d7de22114e7f6d22f138b2850645067993c9577581842464bec7d06937a7427d13d9821d93088008f0ea838b6e475b43725d3b16b60c0e3c821b7fef93

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## master
 
+## 0.20.1 (2020-12-06)
+
+* Make the order of RBS load reproducible ([#508](https://github.com/ruby/rbs/pull/508))
+
+## 0.20.0 (2020-12-06)
+
+* Signature updates for `TSort`, `DBM`, `Time`, and `Hash` ([#496](https://github.com/ruby/rbs/pull/496), [#497](https://github.com/ruby/rbs/pull/497), [#499](https://github.com/ruby/rbs/pull/499), [#507](https://github.com/ruby/rbs/pull/507))
+* Add _singleton attribute_ syntax ([#502](https://github.com/ruby/rbs/pull/502), [#506](https://github.com/ruby/rbs/pull/506), [#505](https://github.com/ruby/rbs/pull/505))
+* Proc types with blocks ([#503](https://github.com/ruby/rbs/pull/503))
+* Add support for escape sequences in string literal types ([#501](https://github.com/ruby/rbs/pull/501))
+* Fix runtime type checking of blocks with keyword args ([#500](https://github.com/ruby/rbs/pull/500))
+
+## 0.19.0 (2020-12-02)
+
+* Signature updates for `Monitor` and File ([#485](https://github.com/ruby/rbs/pull/485), [#495](https://github.com/ruby/rbs/pull/495))
+
+## 0.18.1 (2020-12-01)
+
+* Fix `EnvironmentWalker#each_type_name` ([#494](https://github.com/ruby/rbs/pull/494))
+
+## 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/file.rbs

@@ -192,10 +192,6 @@ class File < IO
   #
   def self.exist?: (string | _ToPath | IO file_name) -> bool
 
-  # Deprecated method. Don't use.
-  #
-  alias self.exists? self.exist?
-
   # 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

data/core/hash.rbs

@@ -563,8 +563,6 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   alias include? has_key?
 
-  def index: (V) -> K?
-
   # Return the contents of this hash as a string.
   #
   #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
@@ -615,7 +613,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.key(300)   #=> "c"
   #     h.key(999)   #=> nil
   #
-  alias key index
+  def key: (V) -> K?
 
   # Returns `true` if the given key is present in *hsh*.
   #

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/core/time.rbs

@@ -757,18 +757,6 @@ class Time < Object
   #
   def subsec: () -> Numeric
 
-  # Returns a new Time object, one second later than *time*. Time#succ is obsolete
-  # since 1.9.2 for time is not a discrete value.
-  #
-  #     t = Time.now       #=> 2007-11-19 08:23:57 -0600
-  #     t.succ             #=> 2007-11-19 08:23:58 -0600
-  #
-  # Use instead `time + 1`
-  #
-  #     t + 1              #=> 2007-11-19 08:23:58 -0600
-  #
-  def succ: () -> Time
-
   # Returns `true` if *time* represents Sunday.
   #
   #     t = Time.local(1990, 4, 1)       #=> 1990-04-01 00:00:00 -0600

data/lib/rbs/ast/members.rb

@@ -216,31 +216,34 @@ module RBS
       module Attribute
         attr_reader :name
         attr_reader :type
+        attr_reader :kind
         attr_reader :ivar_name
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
 
-        def initialize(name:, type:, ivar_name:, annotations:, location:, comment:)
+        def initialize(name:, type:, ivar_name:, kind:, annotations:, location:, comment:)
           @name = name
           @type = type
           @ivar_name = ivar_name
           @annotations = annotations
           @location = location
           @comment = comment
+          @kind = kind
         end
 
         def ==(other)
           other.is_a?(self.class) &&
             other.name == name &&
             other.type == type &&
-            other.ivar_name == ivar_name
+            other.ivar_name == ivar_name &&
+            other.kind == kind
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash ^ ivar_name.hash
+          self.class.hash ^ name.hash ^ type.hash ^ ivar_name.hash ^ kind.hash
         end
       end
 
@@ -253,6 +256,7 @@ module RBS
             name: name,
             type: type,
             ivar_name: ivar_name,
+            kind: kind,
             annotations: annotations,
             location: location,
             comment: comment
@@ -269,6 +273,7 @@ module RBS
             name: name,
             type: type,
             ivar_name: ivar_name,
+            kind: kind,
             annotations: annotations,
             location: location,
             comment: comment
@@ -285,6 +290,7 @@ module RBS
             name: name,
             type: type,
             ivar_name: ivar_name,
+            kind: kind,
             annotations: annotations,
             location: location,
             comment: comment

data/lib/rbs/definition_builder.rb

@@ -558,7 +558,7 @@ module RBS
             )
           end
 
-          unless array.all? {|pair| pair[1] == :public}
+          unless array.all? {|pair| pair[1] == :public }
             raise InconsistentMethodVisibilityError.new(
               type_name: type_name,
               method_name: method_name,
@@ -658,65 +658,12 @@ module RBS
             each_member_with_accessibility(d.decl.members) do |member, accessibility|
               case member
               when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
-                name = member.name
-                type = member.type
-
-                ivar_name = case member.ivar_name
-                            when false
-                              nil
-                            else
-                              member.ivar_name || :"@#{member.name}"
-                            end
-
-                if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
-                  definition.methods[name] = Definition::Method.new(
-                    super_method: nil,
-                    defs: [
-                      Definition::Method::TypeDef.new(
-                        type: MethodType.new(
-                          type_params: [],
-                          type: Types::Function.empty(type),
-                          block: nil,
-                          location: nil
-                        ),
-                        member: member,
-                        defined_in: type_name,
-                        implemented_in: type_name
-                      )
-                    ],
-                    accessibility: accessibility,
-                    alias_of: nil
-                  )
-                end
-
-                if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
-                  definition.methods[:"#{name}="] = Definition::Method.new(
-                    super_method: nil,
-                    defs: [
-                      Definition::Method::TypeDef.new(
-                        type: MethodType.new(
-                          type_params: [],
-                          type: Types::Function.empty(type).update(
-                            required_positionals: [Types::Function::Param.new(name: name, type: type)]
-                          ),
-                          block: nil,
-                          location: nil
-                        ),
-                        member: member,
-                        defined_in: type_name,
-                        implemented_in: type_name
-                      ),
-                    ],
-                    accessibility: accessibility,
-                    alias_of: nil
-                  )
-                end
-
-                if ivar_name
-                  definition.instance_variables[ivar_name] = Definition::Variable.new(
-                    parent_variable: nil,
-                    type: type,
-                    declared_in: type_name
+                if member.kind == :instance
+                  build_attribute(
+                    type_name: type_name,
+                    definition: definition,
+                    member: member,
+                    accessibility: accessibility
                   )
                 end
 
@@ -982,8 +929,16 @@ module RBS
           end
 
           entry.decls.each do |d|
-            each_member_with_accessibility(d.decl.members) do |member, _|
+            each_member_with_accessibility(d.decl.members) do |member, accessibility|
               case member
+              when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
+                if member.kind == :singleton
+                  build_attribute(type_name: type_name,
+                                  definition: definition,
+                                  member: member,
+                                  accessibility: accessibility)
+                end
+
               when AST::Members::ClassInstanceVariable
                 definition.instance_variables[member.name] = Definition::Variable.new(
                   parent_variable: nil,
@@ -1004,6 +959,70 @@ module RBS
       end
     end
 
+    def build_attribute(type_name:, definition:, member:, accessibility:)
+      name = member.name
+      type = member.type
+
+      ivar_name = case member.ivar_name
+                  when false
+                    nil
+                  else
+                    member.ivar_name || :"@#{member.name}"
+                  end
+
+      if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
+        definition.methods[name] = Definition::Method.new(
+          super_method: nil,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: MethodType.new(
+                type_params: [],
+                type: Types::Function.empty(type),
+                block: nil,
+                location: nil
+              ),
+              member: member,
+              defined_in: type_name,
+              implemented_in: type_name
+            )
+          ],
+          accessibility: accessibility,
+          alias_of: nil
+        )
+      end
+
+      if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
+        definition.methods[:"#{name}="] = Definition::Method.new(
+          super_method: nil,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: MethodType.new(
+                type_params: [],
+                type: Types::Function.empty(type).update(
+                  required_positionals: [Types::Function::Param.new(name: name, type: type)]
+                ),
+                block: nil,
+                location: nil
+              ),
+              member: member,
+              defined_in: type_name,
+              implemented_in: type_name
+            ),
+          ],
+          accessibility: accessibility,
+          alias_of: nil
+        )
+      end
+
+      if ivar_name
+        definition.instance_variables[ivar_name] = Definition::Variable.new(
+          parent_variable: nil,
+          type: type,
+          declared_in: type_name
+        )
+      end
+    end
+
     def merge_definitions(type_name, pairs, entry:, self_type:, ancestors:)
       Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
         pairs.reverse_each do |ancestor, current_definition|

data/lib/rbs/environment.rb

@@ -349,6 +349,7 @@ module RBS
         AST::Members::AttrAccessor.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
@@ -358,6 +359,7 @@ module RBS
         AST::Members::AttrReader.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
@@ -367,6 +369,7 @@ module RBS
         AST::Members::AttrWriter.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,