rbs 0.16.0 → 0.20.0

data/core/io.rbs

@@ -105,7 +105,7 @@
 class IO < Object
   include File::Constants
 
-  include Enumerable[String, IO]
+  include Enumerable[String]
 
   def <<: (untyped arg0) -> self
 

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/range.rbs

@@ -88,7 +88,7 @@
 # r.member?(Xs.new(5))       #=> true
 # ```
 class Range[out Elem] < Object
-  include Enumerable[Elem, Range[Elem]]
+  include Enumerable[Elem]
 
   def ==: (untyped obj) -> bool
 

data/core/struct.rbs

@@ -27,7 +27,7 @@
 # struct member which is either a quoted string ( `"name"` ) or a
 # [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html) ( `:name` ).
 class Struct[Elem] < Object
-  include Enumerable[Elem, Struct[Elem]]
+  include Enumerable[Elem]
 
   type attribute_name = Symbol | String
 

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.rb

@@ -60,12 +60,14 @@ module RBS
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :alias_of
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [])
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
         @extra_annotations = annotations
+        @alias_of = alias_of
       end
 
       def defined_in
@@ -110,7 +112,8 @@ module RBS
         self.class.new(
           super_method: super_method&.sub(s),
           defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -118,7 +121,8 @@ module RBS
         self.class.new(
           super_method: super_method&.map_type(&block),
           defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -126,7 +130,8 @@ module RBS
         self.class.new(
           super_method: super_method,
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
     end

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,
@@ -599,10 +599,15 @@ module RBS
       try_cache(type_name, cache: one_instance_cache) do
         entry = env.class_decls[type_name]
 
+        param_names = entry.type_params.each.map(&:name)
         self_type = Types::ClassInstance.new(name: type_name,
-                                             args: Types::Variable.build(entry.type_params.each.map(&:name)),
+                                             args: Types::Variable.build(param_names),
                                              location: nil)
-        ancestors = [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
+        ancestors = Definition::InstanceAncestors.new(
+          type_name: type_name,
+          params: param_names,
+          ancestors: [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
+        )
 
         Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
           method_definition_members(type_name, entry, kind: :instance).each do |method_name, array|
@@ -618,13 +623,15 @@ module RBS
                   Definition::Method.new(
                     super_method: nil,
                     accessibility: visibility,
-                    defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
+                    defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) },
+                    alias_of: nil
                   )
                 else
                   Definition::Method.new(
                     super_method: nil,
                     accessibility: visibility,
-                    defs: []
+                    defs: [],
+                    alias_of: nil
                   )
                 end
 
@@ -641,7 +648,8 @@ module RBS
               Definition::Method.new(
                 super_method: nil,
                 defs: defs + original.defs,
-                accessibility: original.accessibility
+                accessibility: original.accessibility,
+                alias_of: nil
               )
             end
           end
@@ -650,66 +658,15 @@ 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
-                      )
-                    ],
+                if member.kind == :instance
+                  build_attribute(
+                    type_name: type_name,
+                    definition: definition,
+                    member: member,
                     accessibility: accessibility
                   )
                 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
-                  )
-                end
-
-                if ivar_name
-                  definition.instance_variables[ivar_name] = Definition::Variable.new(
-                    parent_variable: nil,
-                    type: type,
-                    declared_in: type_name
-                  )
-                end
-
               when AST::Members::InstanceVariable
                 definition.instance_variables[member.name] = Definition::Variable.new(
                   parent_variable: nil,
@@ -747,7 +704,15 @@ module RBS
                     location: member.location
                   )
 
-                  definition.methods[member.new_name] = definition.methods[member.old_name]
+                  original_method = definition.methods[member.old_name]
+
+                  definition.methods[member.new_name] = Definition::Method.new(
+                    super_method: original_method.super_method,
+                    defs: original_method.defs,
+                    accessibility: original_method.accessibility,
+                    alias_of: original_method,
+                    annotations: original_method.annotations
+                  )
                 end
               end
             end
@@ -838,7 +803,10 @@ module RBS
         entry = env.class_decls[type_name]
 
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-        ancestors = [Definition::Ancestor::Singleton.new(name: type_name)]
+        ancestors = Definition::SingletonAncestors.new(
+          type_name: type_name,
+          ancestors: [Definition::Ancestor::Singleton.new(name: type_name)]
+        )
 
         Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
           method_definition_members(type_name, entry, kind: :singleton).each do |method_name, array|
@@ -855,7 +823,8 @@ module RBS
               defs: method_def&.yield_self do |method_def|
                 method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
               end || [],
-              accessibility: visibility
+              accessibility: visibility,
+              alias_of: nil
             )
             definition.methods[method_name] = members.inject(m) do |original, new|
               defs = new.types.map do |type|
@@ -869,7 +838,8 @@ module RBS
               Definition::Method.new(
                 super_method: nil,
                 defs: defs + original.defs,
-                accessibility: original.accessibility
+                accessibility: original.accessibility,
+                alias_of: nil
               )
             end
           end
@@ -893,7 +863,14 @@ module RBS
                     location: member.location
                   )
 
-                  definition.methods[member.new_name] = definition.methods[member.old_name]
+                  original_method = definition.methods[member.old_name]
+                  definition.methods[member.new_name] = Definition::Method.new(
+                    super_method: original_method.super_method,
+                    defs: original_method.defs,
+                    accessibility: original_method.accessibility,
+                    alias_of: original_method,
+                    annotations: original_method.annotations
+                  )
                 end
               end
             end
@@ -945,14 +922,23 @@ module RBS
                   )
                 end,
                 accessibility: :public,
-                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")],
+                alias_of: nil
               )
             end
           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,
@@ -973,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|
@@ -1029,7 +1079,8 @@ module RBS
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: sub.mapping.empty? ? defs : defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
+        defs: sub.mapping.empty? ? defs : defs.map {|defn| defn.update(type: defn.type.sub(sub)) },
+        alias_of: nil
       )
     end
 
@@ -1123,7 +1174,8 @@ module RBS
                   implemented_in: nil
                 )
               end,
-              accessibility: :public
+              accessibility: :public,
+              alias_of: nil
             )
             definition.methods[member.name] = method
           end