rbs 1.7.0.beta.4 → 1.8.0

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

@@ -5,14 +5,14 @@
 ```markdown
 _type_ ::= _class-name_ _type-arguments_                (Class instance type)
          | _interface-name_ _type-arguments_            (Interface type)
+         | _alias-name_ _type-arguments_                (Alias type)
          | `singleton(` _class-name_ `)`                (Class singleton type)
-         | _alias-name_                                 (Alias type)
          | _literal_                                    (Literal type)
          | _type_ `|` _type_                            (Union type)
          | _type_ `&` _type_                            (Intersection type)
          | _type_ `?`                                   (Optional type)
-         | `{` _record-name_ `:` _type_ `,` etc. `}`     (Record type)
-         | `[]` | `[` _type_ `,` etc. `]`                (Tuples)
+         | `{` _record-name_ `:` _type_ `,` etc. `}`    (Record type)
+         | `[]` | `[` _type_ `,` etc. `]`               (Tuples)
          | _type-variable_                              (Type variables)
          | `^(` _parameters_ `) ->` _type_              (Proc type)
          | `self`
@@ -35,8 +35,8 @@ _namespace_ ::=                                         (Empty namespace)
               | `::`                                    (Root)
               | _namespace_ /[A-Z]\w*/ `::`             (Namespace)
 
-_type-arguments_ ::=                                    (No application)
-                   | `[` _type_ `,` etc. `]`             (Type application)
+_type-arguments_ ::=                                    (No type arguments)
+                   | `[` _type_ `,` etc. `]`            (Type arguments)
 
 _literal_ ::= _string-literal_
             | _symbol-literal_
@@ -64,25 +64,25 @@ _ToS                          # _ToS interface
 ::MyApp::_Each[String]        # Interface name with namespace and type application
 ```
 
-### Class singleton type
-
-Class singleton type denotes _the type of a singleton object of a class_.
-
-```
-singleton(String)
-singleton(::Hash)            # Class singleton type cannot be parametrized.
-```
-
 ### Alias type
 
 Alias type denotes an alias declared with _alias declaration_.
 
 The name of type aliases starts with lowercase `[a-z]`.
 
-
 ```
 name
 ::JSON::t                    # Alias name with namespace
+list[Integer]                # Type alias can be generic
+```
+
+### Class singleton type
+
+Class singleton type denotes _the type of a singleton object of a class_.
+
+```
+singleton(String)
+singleton(::Hash)            # Class singleton type cannot be parametrized.
 ```
 
 ### Literal type
@@ -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
 
@@ -155,7 +155,7 @@ Elem
 ```
 
 Type variables cannot be distinguished from _class instance types_.
-They are scoped in _class/module/interface declaration_ or _generic method types_.
+They are scoped in _class/module/interface/alias declaration_ or _generic method types_.
 
 ```
 class Ref[T]              # Object is scoped in the class declaration.
@@ -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
 
@@ -415,7 +414,6 @@ These work only as _statements_, not per-method specifier.
 _decl_ ::= _class-decl_                         # Class declaration
          | _module-decl_                        # Module declaration
          | _interface-decl_                     # Interface declaration
-         | _extension-decl_                     # Extension declaration
          | _type-alias-decl_                    # Type alias declaration
          | _const-decl_                         # Constant declaration
          | _global-decl_                        # Global declaration
@@ -435,9 +433,7 @@ _interface-members_ ::= _method-member_              # Method
                       | _include-member_             # Mixin (include)
                       | _alias-member_               # Alias
 
-_extension-decl_ ::= `extension` _class-name_ _type-parameters_ `(` _extension-name_ `)` _members_ `end`
-
-_type-alias-decl_ ::= `type` _alias-name_ `=` _type_
+_type-alias-decl_ ::= `type` _alias-name_ _module-type-parameters_ `=` _type_
 
 _const-decl_ ::= _const-name_ `:` _type_
 
@@ -537,6 +533,12 @@ type subject = Attendee | Speaker
 type JSON::t = Integer | TrueClass | FalseClass | String | Hash[Symbol, t] | Array[t]
 ```
 
+Type alias can be generic like class, module, and interface.
+
+```
+type list[out T] = [T, list[T]] | nil
+```
+
 ### Constant type declaration
 
 You can declare a constant.

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);
@@ -815,6 +815,8 @@ static VALUE parse_simple(parserstate *state) {
   }
   case tULIDENT:
     // fallthrough
+  case tLIDENT:
+    // fallthrough
   case pCOLON2: {
     range name_range;
     range args_range;
@@ -857,19 +859,11 @@ static VALUE parse_simple(parserstate *state) {
     } else if (kind == INTERFACE_NAME) {
       return rbs_interface(typename, types, location);
     } else if (kind == ALIAS_NAME) {
-      return rbs_alias(typename, location);
+      return rbs_alias(typename, types, location);
     } else {
       return Qnil;
     }
   }
-  case tLIDENT: {
-    VALUE location = rbs_location_current_token(state);
-    rbs_loc *loc = rbs_check_location(location);
-    rbs_loc_add_required_child(loc, rb_intern("name"), state->current_token.range);
-    rbs_loc_add_optional_child(loc, rb_intern("args"), NULL_RANGE);
-    VALUE typename = parse_type_name(state, ALIAS_NAME, NULL);
-    return rbs_alias(typename, location);
-  }
   case kSINGLETON: {
     range name_range;
     range type_range;
@@ -1093,12 +1087,98 @@ VALUE parse_const_decl(parserstate *state) {
   return rbs_ast_decl_constant(typename, type, location, comment);
 }
 
+/*
+  module_type_params ::= {} `[` module_type_param `,` ... <`]`>
+                       | {<>}
+
+  module_type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT
+*/
+VALUE parse_module_type_params(parserstate *state, range *rg) {
+  VALUE params = rbs_ast_decl_module_type_params();
+
+  if (state->next_token.type == pLBRACKET) {
+    parser_advance(state);
+
+    rg->start = state->current_token.range.start;
+
+    while (true) {
+      VALUE name;
+      VALUE unchecked = Qfalse;
+      VALUE variance = ID2SYM(rb_intern("invariant"));
+
+      range param_range = NULL_RANGE;
+      range name_range;
+      range variance_range = NULL_RANGE;
+      range unchecked_range = NULL_RANGE;
+
+      param_range.start = state->next_token.range.start;
+
+      if (state->next_token.type == kUNCHECKED) {
+        unchecked = Qtrue;
+        parser_advance(state);
+        unchecked_range = state->current_token.range;
+      }
+
+      if (state->next_token.type == kIN || state->next_token.type == kOUT) {
+        switch (state->next_token.type) {
+        case kIN:
+          variance = ID2SYM(rb_intern("contravariant"));
+          break;
+        case kOUT:
+          variance = ID2SYM(rb_intern("covariant"));
+          break;
+        default:
+          rbs_abort();
+        }
+
+        parser_advance(state);
+        variance_range = state->current_token.range;
+      }
+
+      parser_advance_assert(state, tUIDENT);
+      name_range = state->current_token.range;
+      param_range.end = state->current_token.range.end;
+
+      ID id = INTERN_TOKEN(state, state->current_token);
+      name = ID2SYM(id);
+
+      parser_insert_typevar(state, id);
+
+      VALUE location = rbs_new_location(state->buffer, param_range);
+      rbs_loc *loc = rbs_check_location(location);
+      rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+      rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
+      rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
+
+      VALUE param = rbs_ast_decl_module_type_params_param(name, variance, unchecked, location);
+      rb_funcall(params, rb_intern("add"), 1, param);
+
+      if (state->next_token.type == pCOMMA) {
+        parser_advance(state);
+      }
+
+      if (state->next_token.type == pRBRACKET) {
+        break;
+      }
+    }
+
+    parser_advance_assert(state, pRBRACKET);
+    rg->end = state->current_token.range.end;
+  } else {
+    *rg = NULL_RANGE;
+  }
+
+  return params;
+}
+
 /*
   type_decl ::= {kTYPE} alias_name `=` <type>
 */
 VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotations) {
   range decl_range;
-  range keyword_range, name_range, eq_range;
+  range keyword_range, name_range, params_range, eq_range;
+
+  parser_push_typevar_table(state, true);
 
   decl_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, decl_range.start);
@@ -1108,6 +1188,8 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
   parser_advance(state);
   VALUE typename = parse_type_name(state, ALIAS_NAME, &name_range);
 
+  VALUE type_params = parse_module_type_params(state, &params_range);
+
   parser_advance_assert(state, pEQ);
   eq_range = state->current_token.range;
 
@@ -1118,10 +1200,14 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
   rbs_loc *loc = rbs_check_location(location);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+  rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
   rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
 
+  parser_pop_typevar_table(state);
+
   return rbs_ast_decl_alias(
     typename,
+    type_params,
     type,
     annotations,
     location,
@@ -1184,90 +1270,6 @@ VALUE parse_annotation(parserstate *state) {
   return rbs_ast_annotation(string, location);
 }
 
-/*
-  module_type_params ::= {} `[` module_type_param `,` ... <`]`>
-                       | {<>}
-
-  module_type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT
-*/
-VALUE parse_module_type_params(parserstate *state, range *rg) {
-  VALUE params = rbs_ast_decl_module_type_params();
-
-  if (state->next_token.type == pLBRACKET) {
-    parser_advance(state);
-
-    rg->start = state->current_token.range.start;
-
-    while (true) {
-      VALUE name;
-      VALUE unchecked = Qfalse;
-      VALUE variance = ID2SYM(rb_intern("invariant"));
-
-      range param_range = NULL_RANGE;
-      range name_range;
-      range variance_range = NULL_RANGE;
-      range unchecked_range = NULL_RANGE;
-
-      param_range.start = state->next_token.range.start;
-
-      if (state->next_token.type == kUNCHECKED) {
-        unchecked = Qtrue;
-        parser_advance(state);
-        unchecked_range = state->current_token.range;
-      }
-
-      if (state->next_token.type == kIN || state->next_token.type == kOUT) {
-        switch (state->next_token.type) {
-        case kIN:
-          variance = ID2SYM(rb_intern("contravariant"));
-          break;
-        case kOUT:
-          variance = ID2SYM(rb_intern("covariant"));
-          break;
-        default:
-          rbs_abort();
-        }
-
-        parser_advance(state);
-        variance_range = state->current_token.range;
-      }
-
-      parser_advance_assert(state, tUIDENT);
-      name_range = state->current_token.range;
-      param_range.end = state->current_token.range.end;
-
-      ID id = INTERN_TOKEN(state, state->current_token);
-      name = ID2SYM(id);
-
-      parser_insert_typevar(state, id);
-
-      VALUE location = rbs_new_location(state->buffer, param_range);
-      rbs_loc *loc = rbs_check_location(location);
-      rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
-      rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
-      rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
-
-      VALUE param = rbs_ast_decl_module_type_params_param(name, variance, unchecked, location);
-      rb_funcall(params, rb_intern("add"), 1, param);
-
-      if (state->next_token.type == pCOMMA) {
-        parser_advance(state);
-      }
-
-      if (state->next_token.type == pRBRACKET) {
-        break;
-      }
-    }
-
-    parser_advance_assert(state, pRBRACKET);
-    rg->end = state->current_token.range.end;
-  } else {
-    *rg = NULL_RANGE;
-  }
-
-  return params;
-}
-
 /*
   annotations ::= {} annotation ... <annotation>
                 | {<>}
@@ -1487,6 +1489,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.c

@@ -70,15 +70,16 @@ VALUE rbs_class_singleton(VALUE typename, VALUE location) {
   );
 }
 
-VALUE rbs_alias(VALUE typename, VALUE location) {
-  VALUE args = rb_hash_new();
-  rb_hash_aset(args, ID2SYM(rb_intern("name")), typename);
-  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+VALUE rbs_alias(VALUE typename, VALUE args, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("name")), typename);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("args")), args);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
 
   return CLASS_NEW_INSTANCE(
     RBS_Types_Alias,
     1,
-    &args
+    &kwargs
   );
 }
 
@@ -339,9 +340,10 @@ VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment)
   );
 }
 
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
+  rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
   rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
   rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);

data/ext/rbs_extension/ruby_objs.h

@@ -3,10 +3,10 @@
 
 #include "ruby.h"
 
-VALUE rbs_alias(VALUE typename, VALUE location);
+VALUE rbs_alias(VALUE typename, VALUE args, VALUE location);
 VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, VALUE location);
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
@@ -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/ast/declarations.rb

@@ -362,13 +362,15 @@ module RBS
 
       class Alias < Base
         attr_reader :name
+        attr_reader :type_params
         attr_reader :type
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
 
-        def initialize(name:, type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, type:, annotations:, location:, comment:)
           @name = name
+          @type_params = type_params
           @type = type
           @annotations = annotations
           @location = location
@@ -378,19 +380,21 @@ module RBS
         def ==(other)
           other.is_a?(Alias) &&
             other.name == name &&
+            other.type_params == type_params &&
             other.type == type
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ type.hash
         end
 
         def to_json(state = _ = nil)
           {
             declaration: :alias,
             name: name,
+            type_params: type_params,
             type: type,
             annotations: annotations,
             location: location,

data/lib/rbs/cli.rb

@@ -460,7 +460,7 @@ EOU
 
       env.alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
-        builder.expand_alias(name).tap do |type|
+        builder.expand_alias1(name).tap do |type|
           validator.validate_type type, context: [Namespace.root]
         end
         validator.validate_type_alias(entry: decl)

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