rbs 1.7.0.beta.5 → 1.8.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/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/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/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
@@ -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.
@@ -414,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
@@ -434,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_
 
@@ -536,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>
                 | {<>}

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);

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

@@ -104,9 +104,9 @@ module RBS
           else
             begin
               # git v2.27.0 or greater
-              git 'clone', '--filter=blob:none', remote, git_dir.to_s
+              git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
             rescue CommandError
-              git 'clone', remote, git_dir.to_s
+              git 'clone', remote, git_dir.to_s, chdir: nil
             end
           end
 
@@ -131,7 +131,8 @@ module RBS
         private def git_dir
           @git_dir ||= (
             base = Pathname(ENV['XDG_CACHE_HOME'] || File.expand_path("~/.cache"))
-            dir = base.join('rbs', Digest::SHA256.hexdigest(remote))
+            cache_key = remote.start_with?('.') ? "#{remote}\0#{Dir.pwd}" : remote
+            dir = base.join('rbs', Digest::SHA256.hexdigest(cache_key))
             dir.mkpath
             dir
           )
@@ -149,13 +150,14 @@ module RBS
           git('rev-parse', 'HEAD').chomp
         end
 
-        private def git(*cmd)
-          sh! 'git', *cmd
+        private def git(*cmd, **opt)
+          sh! 'git', *cmd, **opt
         end
 
-        private def sh!(*cmd)
+        private def sh!(*cmd, **opt)
           RBS.logger.debug "$ #{cmd.join(' ')}"
-          (__skip__ = Open3.capture3(*cmd, chdir: git_dir)).then do |out, err, status|
+          opt = { chdir: git_dir }.merge(opt).compact
+          (__skip__ = Open3.capture3(*cmd, **opt)).then do |out, err, status|
             raise CommandError, "Unexpected status #{status.exitstatus}\n\n#{err}" unless status.success?
 
             out

data/lib/rbs/definition_builder.rb

@@ -291,6 +291,10 @@ module RBS
             end
 
             one_ancestors.each_extended_module do |mod|
+              mod.args.each do |arg|
+                validate_type_presence(arg)
+              end
+
               mod_defn = build_instance(mod.name, no_self_types: true)
               merge_definition(src: mod_defn,
                                dest: definition,
@@ -299,6 +303,10 @@ module RBS
 
             interface_methods = {}
             one_ancestors.each_extended_interface do |mod|
+              mod.args.each do |arg|
+                validate_type_presence(arg)
+              end
+
               mod_defn = build_interface(mod.name)
               subst = Substitution.build(mod_defn.type_params, mod.args)
 
@@ -781,9 +789,36 @@ module RBS
     end
 
     def expand_alias(type_name)
-      entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      expand_alias2(type_name, [])
+    end
+
+    def expand_alias1(type_name)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+      as = entry.decl.type_params.each.map { Types::Bases::Any.new(location: nil) }
+      expand_alias2(type_name, as)
+    end
+
+    def expand_alias2(type_name, args)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
-      entry.decl.type
+      params = entry.decl.type_params.each.map(&:name)
+
+      unless params.size == args.size
+        as = "[#{args.join(", ")}]" unless args.empty?
+        ps = "[#{params.join(", ")}]" unless params.empty?
+
+        raise "Invalid type application: type = #{type_name}#{as}, decl = #{type_name}#{ps}"
+      end
+
+      type = entry.decl.type
+
+      unless params.empty?
+        subst = Substitution.build(params, args)
+        type = type.sub(subst)
+      end
+
+      type
     end
 
     def update(env:, except:, ancestor_builder:)
@@ -804,5 +839,26 @@ module RBS
         end
       end
     end
+
+    def validate_type_presence(type)
+      case type
+      when Types::ClassInstance, Types::ClassSingleton, Types::Interface, Types::Alias
+        validate_type_name(type.name, type.location)
+      end
+
+      type.each_type do |type|
+        validate_type_presence(type)
+      end
+    end
+
+    def validate_type_name(name, location)
+      name = name.absolute!
+
+      return if name.class? && env.class_decls.key?(name)
+      return if name.interface? && env.interface_decls.key?(name)
+      return if name.alias? && env.alias_decls.key?(name)
+
+      raise NoTypeFoundError.new(type_name: name, location: location)
+    end
   end
 end

data/lib/rbs/environment.rb

@@ -319,6 +319,7 @@ module RBS
       when AST::Declarations::Alias
         AST::Declarations::Alias.new(
           name: decl.name.with_prefix(prefix),
+          type_params: decl.type_params,
           type: absolute_type(resolver, decl.type, context: context),
           location: decl.location,
           annotations: decl.annotations,

data/lib/rbs/environment_walker.rb

@@ -57,7 +57,7 @@ module RBS
             end
           end
         when name.alias?
-          each_type_node builder.expand_alias(name), &block
+          each_type_node builder.expand_alias1(name), &block
         else
           raise "Unexpected TypeNameNode with type_name=#{name}"
         end
@@ -126,6 +126,9 @@ module RBS
         end
       when RBS::Types::Alias
         yield TypeNameNode.new(type_name: type.name)
+        type.args.each do |ty|
+          each_type_node(ty, &block)
+        end
       when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
         type.types.each do |ty|
           each_type_node ty, &block

data/lib/rbs/errors.rb

@@ -431,4 +431,16 @@ module RBS
       @alias_names.map(&:name).join(', ')
     end
   end
+
+  class NonregularTypeAliasError < LoadingError
+    attr_reader :diagnostic
+    attr_reader :location
+
+    def initialize(diagnostic:, location:)
+      @diagnostic = diagnostic
+      @location = location
+
+      super "#{Location.to_string location}: Nonregular generic type alias is prohibited: #{diagnostic.type_name}, #{diagnostic.nonregular_type}"
+    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)