rbs 1.7.0.beta.4 → 1.7.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afd173e37912ce2897a5ff7b9ec6e54bed7258abd7015ac80ae5fa9baa380df5
-  data.tar.gz: 77b07c52dc592c5f5b01df9d4ab8c91d59942c67f158a8f3386926922e197042
+  metadata.gz: 813a7a51e3db502f844756f75a52356945988ffc9e3230b6ff564d7864af02d4
+  data.tar.gz: 2589b291bd8fa87c7228d3204d2c6b4541617c450e64da2efc28fa658c92f0bb
 SHA512:
-  metadata.gz: e03c35027deec7e866534c1f79fe02060ea5672a3e3e8abe9ac1ae5940f2dd7cd99eeed5ee71d9a5991b3074984a6daaaa58d09c380b0cdcb40c568bae50427d
-  data.tar.gz: 92a8cc1a171669ca98c5e323293258ff774747712fb24c0b342e28da866077fc10f4c4bbb2699857842ca7bba9829c014c3b69b5e80a1690aa77027f55c7b083
+  metadata.gz: 1acea4997b9a4d30da59bb02b0d7bb8afa63794c9102b35efd9627efab007195a60ad3e42ebd1595333cd5965acb1e4d1af576cd23e28efab83da6fed5ee649e
+  data.tar.gz: 4822b8fa8cb7fc652d847d90a1bf15215f8229eda1cd11ef9307e03a4abdc0be1ef3a5b117e6fdd00ec7ad43db8cfd914903125dcacea69a8e477b6b2d1cf917

data/CHANGELOG.md

@@ -2,13 +2,14 @@
 
 ## master
 
-## 1.7.0 (beta.4)
+## 1.7.0 (beta.5)
 
 ### Signature updates
 
 * io/console ([\#783](https://github.com/ruby/rbs/pull/783))
 * `Net::HTTPRequest` ([\#784](https://github.com/ruby/rbs/pull/784))
 * `Tempfile.new`, `Tempfile.create` ([\#792](https://github.com/ruby/rbs/pull/792), [\#791](https://github.com/ruby/rbs/pull/791))
+* `#clone` ([#811](https://github.com/ruby/rbs/pull/811))
 
 ### Library changes
 
@@ -16,6 +17,7 @@
 * Replace RBS::Parser ([#788](https://github.com/ruby/rbs/pull/788), [#789](https://github.com/ruby/rbs/pull/789))
 * Print deprecation warning ([\#801](https://github.com/ruby/rbs/pull/801))
 * Make `Parser::KEYWORDS` a hash ([\#804](https://github.com/ruby/rbs/pull/804))
+* Use _partial clone_ for `rbs collection` installer ([#805](https://github.com/ruby/rbs/pull/805))
 
 ## 1.6.2 (2021-09-09)
 

data/core/binding.rbs

@@ -31,6 +31,8 @@
 class Binding
   public
 
+  def clone: () -> self
+
   # Evaluates the Ruby expression(s) in *string*, in the *binding*'s context.  If
   # the optional *filename* and *lineno* parameters are present, they will be used
   # when reporting syntax errors.

data/core/complex.rbs

@@ -165,8 +165,6 @@ class Complex < Numeric
 
   def ceil: (*untyped) -> bot
 
-  def clone: (?freeze: bool) -> self
-
   def coerce: (Numeric) -> [ Complex, Complex ]
 
   # Returns the complex conjugate.

data/core/float.rbs

@@ -171,8 +171,6 @@ class Float < Numeric
   def ceil: () -> Integer
           | (int digits) -> (Integer | Float)
 
-  def clone: (?freeze: bool) -> self
-
   # Returns an array with both `numeric` and `float` represented as Float objects.
   #
   # This is achieved by converting `numeric` to a Float.

data/core/integer.rbs

@@ -272,8 +272,6 @@ class Integer < Numeric
   #
   def chr: (?encoding) -> String
 
-  def clone: (?freeze: bool) -> self
-
   # Returns an array with both a `numeric` and a `big` represented as Bignum
   # objects.
   #

data/core/numeric.rbs

@@ -416,4 +416,11 @@ class Numeric
   # Returns `true` if `num` has a zero value.
   #
   def zero?: () -> bool
+
+  # Returns +self+.
+  #
+  # Raises an exception if the value for +freeze+ is neither +true+ nor +nil+.
+  #
+  # Related: Numeric#dup.
+  def clone: (?freeze: true?) -> self
 end

data/core/object.rbs

@@ -76,7 +76,7 @@ class Object < BasicObject
   # This method may have class-specific behavior.  If so, that behavior will be
   # documented under the #`initialize_copy` method of the class.
   #
-  def clone: (?freeze: bool) -> self
+  def clone: (?freeze: bool?) -> self
 
   # Defines a singleton method in the receiver. The *method* parameter can be a
   # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it

data/core/proc.rbs

@@ -210,6 +210,8 @@
 #     {test: 1}.to_proc.call(:test)       #=> 1
 #     %i[test many keys].map(&{test: 1})  #=> [1, nil, nil]
 class Proc < Object
+  def clone: () -> self
+
   # Returns the number of mandatory arguments. If the block is declared to
   # take no arguments, returns 0. If the block is known to take exactly n
   # arguments, returns n. If the block has optional arguments, returns -n-1,

data/core/rational.rbs

@@ -175,8 +175,6 @@ class Rational < Numeric
   def ceil: () -> Integer
           | (Integer digits) -> (Integer | Rational)
 
-  def clone: (?freeze: bool) -> self
-
   def coerce: (Numeric) -> [Numeric, Numeric]
 
   def conj: () -> Rational

data/core/unbound_method.rbs

@@ -45,6 +45,19 @@
 #     um.bind(t).call   #=> :original
 #
 class UnboundMethod
+  # Returns a clone of this method.
+  #
+  #   class A
+  #     def foo
+  #       return "bar"
+  #     end
+  #   end
+  #
+  #   m = A.new.method(:foo)
+  #   m.call # => "bar"
+  #   n = m.clone.call # => "bar"
+  def clone: () -> self
+
   # Returns an indication of the number of arguments accepted by a method. Returns
   # a nonnegative integer for methods that take a fixed number of arguments. For
   # Ruby methods that take a variable number of arguments, returns -n-1, where n

data/docs/rbs_by_example.md

@@ -229,9 +229,9 @@ end
 
 ```ruby
 # .rb
-[1,2,3,4,5].select {|num| num.even? }
+[1,2,3,4,5].filter {|num| num.even? }
 # => [2, 4]
-%w[ a b c d e f ].select {|v| v =~ /[aeiou]/ }
+%w[ a b c d e f ].filter {|v| v =~ /[aeiou]/ }
 # => ["a", "e"]
 [1,2,3,4,5].filter
 ```

data/docs/syntax.md

@@ -110,10 +110,10 @@ Array[Integer | String]    # Array of Integer or String
 Intersection type denotes _a type of all of the given types_.
 
 ```
-Integer & String           # Integer and String
+_Reader & _Writer           # _Reader and _Writer
 ```
 
-Note that `&` has higher precedence than `|` that `Integer & String | Symbol` is `(Integer & String) | Symbol`.
+Note that `&` has higher precedence than `|` that `A & B | C` is `(A & B) | C`.
 
 ### Optional type
 
@@ -289,7 +289,6 @@ _method-member_ ::= `def` _method-name_ `:` _method-types_            # Instance
                   | `def self?.` _method-name_ `:` _method-types_     # Singleton and instance method
 
 _method-types_ ::=                                                       # Empty
-                 | `super`                                               # `super` overloading
                  | _type-parameters_ _method-type_ `|` _method-types_    # Overloading types
                  | `...`                                                 # Overloading for duplicate definitions
 

data/ext/rbs_extension/parser.c

@@ -1487,6 +1487,8 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
   case INSTANCE_SINGLETON_KIND:
     k = ID2SYM(rb_intern("singleton_instance"));
     break;
+  default:
+    rbs_abort();
   }
 
   VALUE location = rbs_new_location(state->buffer, member_range);

data/ext/rbs_extension/parserstate.c

@@ -87,7 +87,6 @@ bool parser_typevar_member(parserstate *state, ID id) {
 }
 
 void print_parser(parserstate *state) {
-  pp(state->buffer);
   printf("  current_token = %s (%d...%d)\n", token_type_str(state->current_token.type), state->current_token.range.start.char_pos, state->current_token.range.end.char_pos);
   printf("     next_token = %s (%d...%d)\n", token_type_str(state->next_token.type), state->next_token.range.start.char_pos, state->next_token.range.end.char_pos);
   printf("    next_token2 = %s (%d...%d)\n", token_type_str(state->next_token2.type), state->next_token2.range.start.char_pos, state->next_token2.range.end.char_pos);

data/ext/rbs_extension/rbs_extension.h

@@ -37,4 +37,4 @@ VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes);
  * foo.rbs:11:21...11:25: Syntax error: {message}, token=`{tok source}` ({tok type})
  * ```
  * */
-NORETURN(void) raise_syntax_error(parserstate *state, token tok, const char *fmt, ...);
+PRINTF_ARGS(NORETURN(void) raise_syntax_error(parserstate *state, token tok, const char *fmt, ...), 3, 4);

data/ext/rbs_extension/ruby_objs.h

@@ -41,6 +41,4 @@ VALUE rbs_type_name(VALUE namespace, VALUE name);
 VALUE rbs_union(VALUE types, VALUE location);
 VALUE rbs_variable(VALUE name, VALUE location);
 
-void pp(VALUE object);
-
 #endif

data/lib/rbs/collection/sources/git.rb

@@ -102,7 +102,12 @@ module RBS
               git 'fetch', 'origin'
             end
           else
-            git 'clone', remote, git_dir.to_s
+            begin
+              # git v2.27.0 or greater
+              git 'clone', '--filter=blob:none', remote, git_dir.to_s
+            rescue CommandError
+              git 'clone', remote, git_dir.to_s
+            end
           end
 
           begin

data/lib/rbs/prototype/helpers.rb

@@ -0,0 +1,113 @@
+module RBS
+  module Prototype
+    module Helpers
+      private
+
+      def block_from_body(node)
+        _, args_node, body_node = node.children
+
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
+
+        method_block = nil
+
+        if block
+          method_block = Types::Block.new(
+            # HACK: The `block` is :& on `def m(...)` syntax.
+            #       In this case the block looks optional in most cases, so it marks optional.
+            #       In other cases, we can't determine which is required or optional, so it marks required.
+            required: block != :&,
+            type: Types::Function.empty(untyped)
+          )
+        end
+
+        if body_node
+          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
+            method_block = Types::Block.new(
+              required: true,
+              type: Types::Function.empty(untyped)
+            )
+
+            yields.each do |yield_node|
+              array_content = yield_node.children[0]&.children&.compact || []
+
+              positionals, keywords = if keyword_hash?(array_content.last)
+                                        [array_content.take(array_content.size - 1), array_content.last]
+                                      else
+                                        [array_content, nil]
+                                      end
+
+              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+                diff.times do
+                  method_block.type.required_positionals << Types::Function::Param.new(
+                    type: untyped,
+                    name: nil
+                  )
+                end
+              end
+
+              if keywords
+                keywords.children[0].children.each_slice(2) do |key_node, value_node|
+                  if key_node
+                    key = key_node.children[0]
+                    method_block.type.required_keywords[key] ||=
+                      Types::Function::Param.new(
+                        type: untyped,
+                        name: nil
+                      )
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        method_block
+      end
+
+      def each_child(node, &block)
+        each_node node.children, &block
+      end
+
+      def each_node(nodes)
+        nodes.each do |child|
+          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+            yield child
+          end
+        end
+      end
+
+
+      def any_node?(node, nodes: [], &block)
+        if yield(node)
+          nodes << node
+        end
+
+        each_child node do |child|
+          any_node? child, nodes: nodes, &block
+        end
+
+        nodes.empty? ? nil : nodes
+      end
+
+      def keyword_hash?(node)
+        if node
+          if node.type == :HASH
+            node.children[0].children.compact.each_slice(2).all? {|key, _|
+              key.type == :LIT && key.children[0].is_a?(Symbol)
+            }
+          end
+        end
+      end
+
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
+      end
+
+      def untyped
+        @untyped ||= Types::Bases::Any.new(location: nil)
+      end
+    end
+  end
+end

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class RB
+      include Helpers
+
       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)
@@ -372,18 +374,6 @@ module RBS
         end
       end
 
-      def each_node(nodes)
-        nodes.each do |child|
-          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
-            yield child
-          end
-        end
-      end
-
-      def each_child(node, &block)
-        each_node node.children, &block
-      end
-
       def function_type_from_body(node, def_name)
         table_node, args_node, *_ = node.children
 
@@ -568,95 +558,6 @@ module RBS
         end
       end
 
-      def block_from_body(node)
-        _, args_node, body_node = node.children
-
-        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
-
-        method_block = nil
-
-        if block
-          method_block = Types::Block.new(
-            # HACK: The `block` is :& on `def m(...)` syntax.
-            #       In this case the block looks optional in most cases, so it marks optional.
-            #       In other cases, we can't determine which is required or optional, so it marks required.
-            required: block != :&,
-            type: Types::Function.empty(untyped)
-          )
-        end
-
-        if body_node
-          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = Types::Block.new(
-              required: true,
-              type: Types::Function.empty(untyped)
-            )
-
-            yields.each do |yield_node|
-              array_content = yield_node.children[0]&.children&.compact || []
-
-              positionals, keywords = if keyword_hash?(array_content.last)
-                                        [array_content.take(array_content.size - 1), array_content.last]
-                                      else
-                                        [array_content, nil]
-                                      end
-
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
-                diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
-                    type: untyped,
-                    name: nil
-                  )
-                end
-              end
-
-              if keywords
-                keywords.children[0].children.each_slice(2) do |key_node, value_node|
-                  if key_node
-                    key = key_node.children[0]
-                    method_block.type.required_keywords[key] ||=
-                      Types::Function::Param.new(
-                        type: untyped,
-                        name: nil
-                      )
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        method_block
-      end
-
-      # NOTE: args_node may be a nil by a bug
-      #       https://bugs.ruby-lang.org/issues/17495
-      def args_from_node(args_node)
-        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
-      end
-
-      def keyword_hash?(node)
-        if node
-          if node.type == :HASH
-            node.children[0].children.compact.each_slice(2).all? {|key, _|
-              key.type == :LIT && key.children[0].is_a?(Symbol)
-            }
-          end
-        end
-      end
-
-      def any_node?(node, nodes: [], &block)
-        if yield(node)
-          nodes << node
-        end
-
-        each_child node do |child|
-          any_node? child, nodes: nodes, &block
-        end
-
-        nodes.empty? ? nil : nodes
-      end
-
       def node_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
         when :LIT
@@ -689,10 +590,6 @@ module RBS
         end
       end
 
-      def untyped
-        @untyped ||= Types::Bases::Any.new(location: nil)
-      end
-
       def private
         @private ||= AST::Members::Private.new(location: nil)
       end

data/lib/rbs/prototype/runtime.rb

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class Runtime
+      include Helpers
+
       attr_reader :patterns
       attr_reader :env
       attr_reader :merge
@@ -138,6 +140,8 @@ module RBS
           end
         end
 
+        block ||= block_from_ast_of(method)
+
         return_type = if method.name == :initialize
                         Types::Bases::Void.new(location: nil)
                       else
@@ -522,6 +526,18 @@ module RBS
           []
         end
       end
+
+      def block_from_ast_of(method)
+        return nil if RUBY_VERSION < '3.1'
+
+        begin
+          ast = RubyVM::AbstractSyntaxTree.of(method)
+        rescue ArgumentError
+          return # When the method is defined in eval
+        end
+
+        block_from_body(ast) if ast&.type == :SCOPE
+      end
     end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.7.0.beta.4"
+  VERSION = "1.7.0.beta.5"
 end

data/lib/rbs.rb

@@ -32,6 +32,7 @@ require "rbs/constant"
 require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"
+require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 1.7.0.beta.4
+  version: 1.7.0.beta.5
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-22 00:00:00.000000000 Z
+date: 2021-11-07 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -158,6 +158,7 @@ files:
 - lib/rbs/parser_compat/located_value.rb
 - lib/rbs/parser_compat/semantics_error.rb
 - lib/rbs/parser_compat/syntax_error.rb
+- lib/rbs/prototype/helpers.rb
 - lib/rbs/prototype/rb.rb
 - lib/rbs/prototype/rbi.rb
 - lib/rbs/prototype/runtime.rb