rbs 1.7.0.beta.3 → 1.7.1

data/core/false_class.rbs

@@ -37,4 +37,6 @@ class FalseClass
   def |: (nil) -> false
        | (false) -> false
        | (untyped obj) -> true
+
+  def clone: (?freeze: true?) -> self
 end

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

@@ -79,4 +79,6 @@ class NilClass
   def |: (nil) -> false
        | (false) -> false
        | (untyped obj) -> bool
+
+  def clone: (?freeze: true?) -> self
 end

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

@@ -226,4 +226,6 @@ class Symbol
             | (:ascii | :lithuanian | :turkic) -> Symbol
             | (:lithuanian, :turkic) -> Symbol
             | (:turkic, :lithuanian) -> Symbol
+
+  def clone: (?freeze: true?) -> self
 end

data/core/thread.rbs

@@ -554,7 +554,7 @@ class Thread < Object
   # b = Thread.new { raise 'something went wrong' }
   # b.value   #=> RuntimeError: something went wrong
   # ```
-  def value: () -> Object
+  def value: () -> untyped
 
   # Marks a given thread as eligible for scheduling, however it may still
   # remain blocked on I/O.

data/core/true_class.rbs

@@ -43,4 +43,6 @@ class TrueClass
   #     or
   #
   def |: (untyped obj) -> true
+
+  def clone: (?freeze: true?) -> self
 end

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

@@ -273,7 +273,7 @@ static VALUE parse_function_param(parserstate *state) {
     param_range.start = type_range.start;
     param_range.end = name_range.end;
 
-    VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
+    VALUE name = rb_to_symbol(rbs_unquote_string(state, state->current_token.range, 0));
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
     rbs_loc_add_optional_child(loc, rb_intern("name"), name_range);
@@ -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/parser_aux.rb

@@ -26,38 +26,38 @@ module RBS
     autoload :LexerError, "rbs/parser_compat/lexer_error"
     autoload :LocatedValue, "rbs/parser_compat/located_value"
 
-    KEYWORDS = Set.new(
-      %w(
-        bool
-        bot
-        class
-        instance
-        interface
-        nil
-        self
-        singleton
-        top
-        void
-        type
-        unchecked
-        in
-        out
-        end
-        def
-        include
-        extend
-        prepend
-        alias
-        module
-        attr_reader
-        attr_writer
-        attr_accessor
-        public
-        private
-        untyped
-        true
-        false
-      )
-    )
+    KEYWORDS = %w(
+      bool
+      bot
+      class
+      instance
+      interface
+      nil
+      self
+      singleton
+      top
+      void
+      type
+      unchecked
+      in
+      out
+      end
+      def
+      include
+      extend
+      prepend
+      alias
+      module
+      attr_reader
+      attr_writer
+      attr_accessor
+      public
+      private
+      untyped
+      true
+      false
+      ).each_with_object({}) do |keyword, hash|
+        hash[keyword] = nil
+      end
   end
 end

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/test/setup.rb

@@ -13,6 +13,7 @@ begin
   filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
   skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
   RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
+  logger.level = RBS.logger_level
   sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
   double_class = to_double_class(ENV['RBS_TEST_DOUBLE_SUITE'])
   unchecked_classes = (ENV['RBS_TEST_UNCHECKED_CLASSES'] || '').split(',').map! { |unchecked_class| unchecked_class.strip }.push(*double_class)

data/lib/rbs/types.rb

@@ -690,7 +690,7 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.include?(name)
+            if Parser::KEYWORDS.include?(name.to_s)
               "#{type} `#{name}`"
             else
               "#{type} #{name}"

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.7.0.beta.3"
+  VERSION = "1.7.1"
 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"

data/sig/collection/collections.rbs

@@ -46,6 +46,8 @@ module RBS
 
         def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
 
+        def cp_r: (Pathname, Pathname) -> void
+
         def setup!: (revision: String) -> void
 
         def need_to_fetch?: (String revision ) -> bool

data/sig/parser.rbs

@@ -6,7 +6,7 @@ module RBS
 
     def self.parse_signature: (Buffer | String, ?line: Integer, ?column: Integer) -> Array[AST::Declarations::t]
 
-    KEYWORDS: Set[String]
+    KEYWORDS: Hash[String, bot]
 
     private