rbs-relaxed 3.9.0.1 → 3.9.4.0

data/ext/rbs_extension/parser.c

@@ -61,6 +61,7 @@ typedef struct {
 } method_params;
 
 static VALUE EMPTY_ARRAY;
+static VALUE EMPTY_HASH;
 
 static inline void melt_array(VALUE *array) {
   if (*array == EMPTY_ARRAY) {
@@ -68,6 +69,12 @@ static inline void melt_array(VALUE *array) {
   }
 }
 
+static inline void melt_hash(VALUE *hash) {
+  if (*hash == EMPTY_HASH) {
+    *hash = rb_hash_new();
+  }
+}
+
 static bool rbs_is_untyped_params(method_params *params) {
   return NIL_P(params->required_positionals);
 }
@@ -343,7 +350,7 @@ static VALUE parse_keyword_key(parserstate *state) {
 /*
   keyword ::= {} keyword `:` <function_param>
 */
-static void parse_keyword(parserstate *state, VALUE keywords, VALUE memo) {
+static void parse_keyword(parserstate *state, VALUE *keywords, VALUE memo) {
   VALUE key = parse_keyword_key(state);
 
   if (!NIL_P(rb_hash_aref(memo, key))) {
@@ -359,7 +366,8 @@ static void parse_keyword(parserstate *state, VALUE keywords, VALUE memo) {
   parser_advance_assert(state, pCOLON);
   VALUE param = parse_function_param(state);
 
-  rb_hash_aset(keywords, key, param);
+  melt_hash(keywords);
+  rb_hash_aset(*keywords, key, param);
 
   return;
 }
@@ -466,7 +474,7 @@ PARSE_OPTIONAL_PARAMS:
         parser_advance(state);
 
         if (is_keyword(state)) {
-          parse_keyword(state, params->optional_keywords, memo);
+          parse_keyword(state, &params->optional_keywords, memo);
           parser_advance_if(state, pCOMMA);
           goto PARSE_KEYWORDS;
         }
@@ -533,7 +541,7 @@ PARSE_KEYWORDS:
     case pQUESTION:
       parser_advance(state);
       if (is_keyword(state)) {
-        parse_keyword(state, params->optional_keywords, memo);
+        parse_keyword(state, &params->optional_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -556,7 +564,7 @@ PARSE_KEYWORDS:
     case tBANGIDENT:
     KEYWORD_CASES
       if (is_keyword(state)) {
-        parse_keyword(state, params->required_keywords, memo);
+        parse_keyword(state, &params->required_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -613,8 +621,8 @@ static void initialize_method_params(method_params *params){
     .optional_positionals = EMPTY_ARRAY,
     .rest_positionals = Qnil,
     .trailing_positionals = EMPTY_ARRAY,
-    .required_keywords = rb_hash_new(),
-    .optional_keywords = rb_hash_new(),
+    .required_keywords = EMPTY_HASH,
+    .optional_keywords = EMPTY_HASH,
     .rest_keywords = Qnil,
   };
 }
@@ -653,16 +661,16 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
     parser_advance_assert(state, pRPAREN);
   }
 
-  // Untyped method parameter means it cannot have block
-  if (rbs_is_untyped_params(&params)) {
-    if (state->next_token.type != pARROW) {
-      raise_syntax_error(state, state->next_token2, "A method type with untyped method parameter cannot have block");
-    }
-  }
-
   // Passing NULL to function_self_type means the function itself doesn't accept self type binding. (== method type)
   if (function_self_type) {
     *function_self_type = parse_self_type_binding(state);
+  } else {
+    // Parsing method type. untyped_params means it cannot have a block
+    if (rbs_is_untyped_params(&params)) {
+      if (state->next_token.type != pARROW) {
+        raise_syntax_error(state, state->next_token2, "A method type with untyped method parameter cannot have block");
+      }
+    }
   }
 
   VALUE required = Qtrue;
@@ -1088,26 +1096,24 @@ static VALUE parse_simple(parserstate *state) {
                  | {} <optional>
 */
 static VALUE parse_intersection(parserstate *state) {
-  range rg;
-  rg.start = state->next_token.range.start;
-
+  position start = state->next_token.range.start;
   VALUE type = parse_optional(state);
-  VALUE intersection_types = rb_ary_new();
+  if (state->next_token.type != pAMP) {
+    return type;
+  }
 
+  VALUE intersection_types = rb_ary_new();
   rb_ary_push(intersection_types, type);
   while (state->next_token.type == pAMP) {
     parser_advance(state);
     rb_ary_push(intersection_types, parse_optional(state));
   }
-
-  rg.end = state->current_token.range.end;
-
-  if (rb_array_len(intersection_types) > 1) {
-    VALUE location = rbs_new_location(state->buffer, rg);
-    type = rbs_intersection(intersection_types, location);
-  }
-
-  return type;
+  range rg = (range) {
+    .start = start,
+    .end = state->current_token.range.end,
+  };
+  VALUE location = rbs_new_location(state->buffer, rg);
+  return rbs_intersection(intersection_types, location);
 }
 
 /*
@@ -1115,26 +1121,24 @@ static VALUE parse_intersection(parserstate *state) {
           | {} <intersection>
 */
 VALUE parse_type(parserstate *state) {
-  range rg;
-  rg.start = state->next_token.range.start;
-
+  position start = state->next_token.range.start;
   VALUE type = parse_intersection(state);
-  VALUE union_types = rb_ary_new();
+  if (state->next_token.type != pBAR) {
+    return type;
+  }
 
+  VALUE union_types = rb_ary_new();
   rb_ary_push(union_types, type);
   while (state->next_token.type == pBAR) {
     parser_advance(state);
     rb_ary_push(union_types, parse_intersection(state));
   }
-
-  rg.end = state->current_token.range.end;
-
-  if (rb_array_len(union_types) > 1) {
-    VALUE location = rbs_new_location(state->buffer, rg);
-    type = rbs_union(union_types, location);
-  }
-
-  return type;
+  range rg = (range) {
+    .start = start,
+    .end = state->current_token.range.end,
+  };
+  VALUE location = rbs_new_location(state->buffer, rg);
+  return rbs_union(union_types, location);
 }
 
 /*
@@ -1314,7 +1318,7 @@ VALUE parse_method_type(parserstate *state) {
 /*
   global_decl ::= {tGIDENT} `:` <type>
 */
-static VALUE parse_global_decl(parserstate *state) {
+static VALUE parse_global_decl(parserstate *state, VALUE annotations) {
   range decl_range;
   decl_range.start = state->current_token.range.start;
 
@@ -1334,13 +1338,13 @@ static VALUE parse_global_decl(parserstate *state) {
   rbs_loc_add_required_child(loc, INTERN("name"), name_range);
   rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
 
-  return rbs_ast_decl_global(typename, type, location, comment);
+  return rbs_ast_decl_global(typename, type, location, comment, annotations);
 }
 
 /*
   const_decl ::= {const_name} `:` <type>
 */
-static VALUE parse_const_decl(parserstate *state) {
+static VALUE parse_const_decl(parserstate *state, VALUE annotations) {
   range decl_range;
 
   decl_range.start = state->current_token.range.start;
@@ -1361,7 +1365,7 @@ static VALUE parse_const_decl(parserstate *state) {
   rbs_loc_add_required_child(loc, INTERN("name"), name_range);
   rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
 
-  return rbs_ast_decl_constant(typename, type, location, comment);
+  return rbs_ast_decl_constant(typename, type, location, comment, annotations);
 }
 
 /*
@@ -2465,7 +2469,7 @@ static VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE a
     rbs_loc_add_required_child(loc, INTERN("eq"), eq_range);
     rbs_loc_add_optional_child(loc, INTERN("old_name"), old_name_range);
 
-    return rbs_ast_decl_module_alias(module_name, old_name, location, comment);
+    return rbs_ast_decl_module_alias(module_name, old_name, location, comment, annotations);
   } else {
     return parse_module_decl0(state, keyword_range, module_name, module_name_range, comment, annotations);
   }
@@ -2582,7 +2586,7 @@ static VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE an
     rbs_loc_add_required_child(loc, INTERN("eq"), eq_range);
     rbs_loc_add_optional_child(loc, INTERN("old_name"), old_name_range);
 
-    return rbs_ast_decl_class_alias(class_name, old_name, location, comment);
+    return rbs_ast_decl_class_alias(class_name, old_name, location, comment, annotations);
   } else {
     return parse_class_decl0(state, keyword_range, class_name, class_name_range, comment, annotations);
   }
@@ -2602,11 +2606,11 @@ static VALUE parse_nested_decl(parserstate *state, const char *nested_in, positi
   switch (state->current_token.type) {
   case tUIDENT:
   case pCOLON2: {
-    decl = parse_const_decl(state);
+    decl = parse_const_decl(state, annotations);
     break;
   }
   case tGIDENT: {
-    decl = parse_global_decl(state);
+    decl = parse_global_decl(state, annotations);
     break;
   }
   case kTYPE: {
@@ -2648,10 +2652,10 @@ static VALUE parse_decl(parserstate *state) {
   switch (state->current_token.type) {
   case tUIDENT:
   case pCOLON2: {
-    return parse_const_decl(state);
+    return parse_const_decl(state, annotations);
   }
   case tGIDENT: {
-    return parse_global_decl(state);
+    return parse_global_decl(state, annotations);
   }
   case kTYPE: {
     return parse_type_decl(state, annot_pos, annotations);
@@ -2962,10 +2966,15 @@ rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
 void rbs__init_parser(void) {
   RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
   rb_gc_register_mark_object(RBS_Parser);
+
   VALUE empty_array = rb_obj_freeze(rb_ary_new());
   rb_gc_register_mark_object(empty_array);
   EMPTY_ARRAY = empty_array;
 
+  VALUE empty_hash = rb_obj_freeze(rb_hash_new());
+  rb_gc_register_mark_object(empty_hash);
+  EMPTY_HASH = empty_hash;
+
   rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 3);

data/ext/rbs_extension/parserstate.c

@@ -334,7 +334,7 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
     .vars = NULL,
     .last_comment = NULL,
 
-    .constant_pool = {},
+    .constant_pool = { 0 },
   };
 
   // The parser's constant pool is mainly used for storing the names of type variables, which usually aren't many.
@@ -363,6 +363,7 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
 
   if (!NIL_P(variables)) {
     if (!RB_TYPE_P(variables, T_ARRAY)) {
+      free_parser(parser);
       rb_raise(rb_eTypeError,
                "wrong argument type %"PRIsVALUE" (must be array or nil)",
                rb_obj_class(variables));
@@ -387,11 +388,24 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
   return parser;
 }
 
+void free_typevar_tables(id_table *table) {
+  while (table != NULL) {
+    id_table *next = table->next;
+    if (table->ids != NULL) {
+      free(table->ids);
+    }
+    free(table);
+    table = next;
+  }
+}
+
 void free_parser(parserstate *parser) {
   free(parser->lexstate);
   if (parser->last_comment) {
     free_comment(parser->last_comment);
   }
+
+  free_typevar_tables(parser->vars);
   rbs_constant_pool_free(&parser->constant_pool);
   free(parser);
 }

data/include/rbs/ruby_objs.h

@@ -14,13 +14,13 @@ VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, 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_class_super(VALUE name, VALUE args, VALUE location);
-VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
-VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
-VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment, VALUE annotations);
 VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
-VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment, VALUE annotations);
 VALUE rbs_ast_decl_type_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_directives_use(VALUE clauses, VALUE location);
 VALUE rbs_ast_directives_use_single_clause(VALUE type_name, VALUE new_name, VALUE location);

data/lib/rbs/ast/declarations.rb

@@ -349,12 +349,14 @@ module RBS
         attr_reader :type
         attr_reader :location
         attr_reader :comment
+        attr_reader :annotations
 
-        def initialize(name:, type:, location:, comment:)
+        def initialize(name:, type:, location:, comment:, annotations: [])
           @name = name
           @type = type
           @location = location
           @comment = comment
+          @annotations = annotations || []
         end
 
         def ==(other)
@@ -385,12 +387,14 @@ module RBS
         attr_reader :type
         attr_reader :location
         attr_reader :comment
+        attr_reader :annotations
 
-        def initialize(name:, type:, location:, comment:)
+        def initialize(name:, type:, location:, comment:, annotations: [])
           @name = name
           @type = type
           @location = location
           @comment = comment
+          @annotations = annotations
         end
 
         def ==(other)
@@ -417,13 +421,14 @@ module RBS
       end
 
       class AliasDecl < Base
-        attr_reader :new_name, :old_name, :location, :comment
+        attr_reader :new_name, :old_name, :location, :comment, :annotations
 
-        def initialize(new_name:, old_name:, location:, comment:)
+        def initialize(new_name:, old_name:, location:, comment:, annotations: [])
           @new_name = new_name
           @old_name = old_name
           @location = location
           @comment = comment
+          @annotations = annotations
         end
 
         def ==(other)

data/lib/rbs/ast/type_param.rb

@@ -56,16 +56,6 @@ module RBS
         }.to_json(state)
       end
 
-      def rename(name)
-        TypeParam.new(
-          name: name,
-          variance: variance,
-          upper_bound: upper_bound_type,
-          location: location,
-          default_type: default_type
-        ).unchecked!(unchecked?)
-      end
-
       def map_type(&block)
         if b = upper_bound_type
           _upper_bound_type = yield(b)

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -4,7 +4,17 @@ module RBS
   module Collection
     class Config
       class LockfileGenerator
-        ALUMNI_STDLIBS = { "mutex_m" => ">= 0.3.0" }
+        ALUMNI_STDLIBS = {
+          "mutex_m" => ">= 0.3.0",
+          "abbrev" => nil,
+          "base64" => nil,
+          "bigdecimal" => nil,
+          "csv" => nil,
+          "minitest" => nil,
+          "net-smtp" => nil,
+          "nkf" => nil,
+          "observer" => nil,
+        }
 
         class GemfileLockMismatchError < StandardError
           def initialize(expected:, actual:)
@@ -161,12 +171,24 @@ module RBS
           return if lockfile.gems.key?(name)
 
           case name
+          when 'bigdecimal-math'
+            # The `bigdecimal-math` is never released as a gem.
+            # Therefore, `assign_gem` should not be called.
+            RBS.logger.info {
+              from = from_gem || "rbs_collection.yaml"
+              "`#{name}` is included in the RBS dependencies of `#{from}`, but the type definition as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies of `#{from}`."
+            }
+            source = find_source(name: name)
+            if source&.is_a?(Sources::Stdlib)
+              lockfile.gems[name] = { name: name, version: "0", source: source }
+            end
+            return
           when *ALUMNI_STDLIBS.keys
             version = ALUMNI_STDLIBS.fetch(name)
             if from_gem
               # From `dependencies:` of a `manifest.yaml` of a gem
               source = find_source(name: name) or raise
-              if source.is_a?(Sources::Stdlib)
+              if source.is_a?(Sources::Stdlib) && version
                 RBS.logger.warn {
                   "`#{name}` is included in the RBS dependencies of `#{from_gem}`, but the type definition as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
                 }
@@ -180,7 +202,11 @@ module RBS
             else
               # From `gems:` of a `rbs_collection.yaml`
               RBS.logger.warn {
-                "`#{name}` as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+                if version
+                  "`#{name}` as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+                else
+                  "`#{name}` as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies in your rbs_collection.yaml."
+                end
               }
             end
           end

data/lib/rbs/definition.rb

@@ -6,11 +6,13 @@ module RBS
       attr_reader :parent_variable
       attr_reader :type
       attr_reader :declared_in
+      attr_reader :source
 
-      def initialize(parent_variable:, type:, declared_in:)
+      def initialize(parent_variable:, type:, declared_in:, source:)
         @parent_variable = parent_variable
         @type = type
         @declared_in = declared_in
+        @source = source
       end
 
       def sub(s)
@@ -19,7 +21,8 @@ module RBS
         self.class.new(
           parent_variable: parent_variable,
           type: type.sub(s),
-          declared_in: declared_in
+          declared_in: declared_in,
+          source: source
         )
       end
     end
@@ -39,9 +42,9 @@ module RBS
           @member = member
           @defined_in = defined_in
           @implemented_in = implemented_in
-          @member_annotations = member.annotations
-          @overload_annotations = overload_annotations
-          @annotations = member.annotations + overload_annotations
+          @member_annotations = []
+          @overload_annotations = []
+          @annotations = []
         end
 
         def ==(other)
@@ -63,7 +66,10 @@ module RBS
         end
 
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
-          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in, overload_annotations: overload_annotations)
+          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in).tap do |type_def|
+            type_def.overload_annotations.replace(self.overload_annotations)
+            type_def.member_annotations.replace(self.member_annotations)
+          end
         end
 
         def overload?
@@ -74,20 +80,33 @@ module RBS
             false
           end
         end
+
+        def each_annotation(&block)
+          if block
+            member_annotations.each(&block)
+            overload_annotations.each(&block)
+          else
+            enum_for :each_annotation
+          end
+        end
       end
 
       attr_reader :super_method
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :annotations
       attr_reader :alias_of
+      attr_reader :alias_member
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:, alias_member: nil)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
         @extra_annotations = []
+        @annotations = []
         @alias_of = alias_of
+        @alias_member = alias_member
       end
 
       def ==(other)
@@ -96,7 +115,8 @@ module RBS
           other.defs == defs &&
           other.accessibility == accessibility &&
           other.annotations == annotations &&
-          other.alias_of == alias_of
+          other.alias_of == alias_of &&
+          other.alias_member == alias_member
       end
 
       alias eql? ==
@@ -127,10 +147,6 @@ module RBS
         @comments ||= defs.map(&:comment).compact.uniq
       end
 
-      def annotations
-        @annotations ||= defs.flat_map {|d| d.member_annotations }
-      end
-
       def members
         @members ||= defs.map(&:member).uniq
       end
@@ -146,49 +162,42 @@ module RBS
       def sub(s)
         return self if s.empty?
 
-        self.class.new(
+        update(
           super_method: super_method&.sub(s),
-          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) }
         )
       end
 
       def map_type(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) }
         )
       end
 
       def map_type_bound(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type_bound(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) }
         )
       end
 
       def map_method_type(&block)
-        self.class.new(
-          super_method: super_method,
+        update(
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
         )
       end
 
-      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations)
+      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations, alias_member: self.alias_member)
         self.class.new(
           super_method: super_method,
           defs: defs,
           accessibility: accessibility,
           alias_of: alias_of,
-          annotations: annotations
-        )
+          alias_member: alias_member
+        ).tap do |method|
+          method.annotations.replace(annotations)
+        end
       end
     end
 

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -217,6 +217,7 @@ module RBS
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
+              InvalidTypeApplicationError.check2!(type_name: super_class.name, args: super_class.args, env: env, location: super_class.location)
             end
 
             super_entry = env.normalized_class_entry(super_name) or raise
@@ -243,6 +244,7 @@ module RBS
           else
             entry.self_types.each do |module_self|
               NoSelfTypeFoundError.check!(module_self, env: env)
+              InvalidTypeApplicationError.check2!(type_name: module_self.name, args: module_self.args, env: env, location: module_self.location)
 
               module_name = module_self.name
               if module_name.class?