rbs 4.1.0 → 4.2.0

data/include/rbs/ast.h

@@ -125,18 +125,19 @@ enum rbs_node_type {
     RBS_TYPES_CLASS_INSTANCE = 63,
     RBS_TYPES_CLASS_SINGLETON = 64,
     RBS_TYPES_FUNCTION = 65,
-    RBS_TYPES_FUNCTION_PARAM = 66,
-    RBS_TYPES_INTERFACE = 67,
-    RBS_TYPES_INTERSECTION = 68,
-    RBS_TYPES_LITERAL = 69,
-    RBS_TYPES_OPTIONAL = 70,
-    RBS_TYPES_PROC = 71,
-    RBS_TYPES_RECORD = 72,
-    RBS_TYPES_RECORD_FIELD_TYPE = 73,
-    RBS_TYPES_TUPLE = 74,
-    RBS_TYPES_UNION = 75,
-    RBS_TYPES_UNTYPED_FUNCTION = 76,
-    RBS_TYPES_VARIABLE = 77,
+    RBS_TYPES_FUNCTION_FORWARDING_PARAM = 66,
+    RBS_TYPES_FUNCTION_PARAM = 67,
+    RBS_TYPES_INTERFACE = 68,
+    RBS_TYPES_INTERSECTION = 69,
+    RBS_TYPES_LITERAL = 70,
+    RBS_TYPES_OPTIONAL = 71,
+    RBS_TYPES_PROC = 72,
+    RBS_TYPES_RECORD = 73,
+    RBS_TYPES_RECORD_FIELD_TYPE = 74,
+    RBS_TYPES_TUPLE = 75,
+    RBS_TYPES_UNION = 76,
+    RBS_TYPES_UNTYPED_FUNCTION = 77,
+    RBS_TYPES_VARIABLE = 78,
     RBS_AST_SYMBOL,
 };
 
@@ -583,7 +584,7 @@ typedef struct rbs_ast_ruby_annotations_class_alias_annotation {
 
     rbs_location_range prefix_location;
     rbs_location_range keyword_location;
-    struct rbs_type_name *RBS_NONNULL type_name;
+    struct rbs_type_name *RBS_NULLABLE type_name;
     rbs_location_range type_name_location;
 } rbs_ast_ruby_annotations_class_alias_annotation_t;
 
@@ -631,7 +632,7 @@ typedef struct rbs_ast_ruby_annotations_module_alias_annotation {
 
     rbs_location_range prefix_location;
     rbs_location_range keyword_location;
-    struct rbs_type_name *RBS_NONNULL type_name;
+    struct rbs_type_name *RBS_NULLABLE type_name;
     rbs_location_range type_name_location;
 } rbs_ast_ruby_annotations_module_alias_annotation_t;
 
@@ -854,9 +855,15 @@ typedef struct rbs_types_function {
     struct rbs_hash *RBS_NONNULL required_keywords;
     struct rbs_hash *RBS_NONNULL optional_keywords;
     struct rbs_node *RBS_NULLABLE rest_keywords;
+    struct rbs_node *RBS_NULLABLE forwarding;
     struct rbs_node *RBS_NONNULL return_type;
 } rbs_types_function_t;
 
+typedef struct rbs_types_function_forwarding_param {
+    rbs_node_t base;
+
+} rbs_types_function_forwarding_param_t;
+
 typedef struct rbs_types_function_param {
     rbs_node_t base;
 
@@ -998,12 +1005,12 @@ rbs_ast_members_prepend_t *RBS_NONNULL rbs_ast_members_prepend_new(rbs_allocator
 rbs_ast_members_private_t *RBS_NONNULL rbs_ast_members_private_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location);
 rbs_ast_members_public_t *RBS_NONNULL rbs_ast_members_public_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location);
 rbs_ast_ruby_annotations_block_param_type_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_block_param_type_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range ampersand_location, rbs_location_range name_location, rbs_location_range colon_location, rbs_location_range question_location, rbs_location_range type_location, rbs_node_t *RBS_NONNULL type_, rbs_location_range comment_location);
-rbs_ast_ruby_annotations_class_alias_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_class_alias_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range keyword_location, rbs_type_name_t *RBS_NONNULL type_name, rbs_location_range type_name_location);
+rbs_ast_ruby_annotations_class_alias_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_class_alias_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range keyword_location, rbs_type_name_t *RBS_NULLABLE type_name, rbs_location_range type_name_location);
 rbs_ast_ruby_annotations_colon_method_type_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_colon_method_type_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_node_list_t *RBS_NONNULL annotations, rbs_node_t *RBS_NONNULL method_type);
 rbs_ast_ruby_annotations_double_splat_param_type_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_double_splat_param_type_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range star2_location, rbs_location_range name_location, rbs_location_range colon_location, rbs_node_t *RBS_NONNULL param_type, rbs_location_range comment_location);
 rbs_ast_ruby_annotations_instance_variable_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_instance_variable_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_ast_symbol_t *RBS_NONNULL ivar_name, rbs_location_range ivar_name_location, rbs_location_range colon_location, rbs_node_t *RBS_NONNULL type, rbs_location_range comment_location);
 rbs_ast_ruby_annotations_method_types_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_method_types_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_node_list_t *RBS_NONNULL overloads, rbs_location_range_list_t *RBS_NONNULL vertical_bar_locations, rbs_location_range dot3_location);
-rbs_ast_ruby_annotations_module_alias_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_module_alias_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range keyword_location, rbs_type_name_t *RBS_NONNULL type_name, rbs_location_range type_name_location);
+rbs_ast_ruby_annotations_module_alias_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_module_alias_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range keyword_location, rbs_type_name_t *RBS_NULLABLE type_name, rbs_location_range type_name_location);
 rbs_ast_ruby_annotations_module_self_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_module_self_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range keyword_location, rbs_location_range colon_location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range open_bracket_location, rbs_location_range close_bracket_location, rbs_location_range_list_t *RBS_NONNULL args_comma_locations, rbs_location_range comment_location);
 rbs_ast_ruby_annotations_node_type_assertion_t *RBS_NONNULL rbs_ast_ruby_annotations_node_type_assertion_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_node_t *RBS_NONNULL type);
 rbs_ast_ruby_annotations_param_type_annotation_t *RBS_NONNULL rbs_ast_ruby_annotations_param_type_annotation_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_location_range prefix_location, rbs_location_range name_location, rbs_location_range colon_location, rbs_node_t *RBS_NONNULL param_type, rbs_location_range comment_location);
@@ -1030,7 +1037,8 @@ rbs_types_bases_void_t *RBS_NONNULL rbs_types_bases_void_new(rbs_allocator_t *RB
 rbs_types_block_t *RBS_NONNULL rbs_types_block_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_t *RBS_NONNULL type, bool required, rbs_node_t *RBS_NULLABLE self_type);
 rbs_types_class_instance_t *RBS_NONNULL rbs_types_class_instance_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
 rbs_types_class_singleton_t *RBS_NONNULL rbs_types_class_singleton_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
-rbs_types_function_t *RBS_NONNULL rbs_types_function_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL required_positionals, rbs_node_list_t *RBS_NONNULL optional_positionals, rbs_node_t *RBS_NULLABLE rest_positionals, rbs_node_list_t *RBS_NONNULL trailing_positionals, rbs_hash_t *RBS_NONNULL required_keywords, rbs_hash_t *RBS_NONNULL optional_keywords, rbs_node_t *RBS_NULLABLE rest_keywords, rbs_node_t *RBS_NONNULL return_type);
+rbs_types_function_t *RBS_NONNULL rbs_types_function_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL required_positionals, rbs_node_list_t *RBS_NONNULL optional_positionals, rbs_node_t *RBS_NULLABLE rest_positionals, rbs_node_list_t *RBS_NONNULL trailing_positionals, rbs_hash_t *RBS_NONNULL required_keywords, rbs_hash_t *RBS_NONNULL optional_keywords, rbs_node_t *RBS_NULLABLE rest_keywords, rbs_node_t *RBS_NULLABLE forwarding, rbs_node_t *RBS_NONNULL return_type);
+rbs_types_function_forwarding_param_t *RBS_NONNULL rbs_types_function_forwarding_param_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location);
 rbs_types_function_param_t *RBS_NONNULL rbs_types_function_param_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_t *RBS_NONNULL type, rbs_ast_symbol_t *RBS_NULLABLE name);
 rbs_types_interface_t *RBS_NONNULL rbs_types_interface_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_type_name_t *RBS_NONNULL name, rbs_node_list_t *RBS_NONNULL args, rbs_location_range name_range);
 rbs_types_intersection_t *RBS_NONNULL rbs_types_intersection_new(rbs_allocator_t *RBS_NONNULL allocator, rbs_location_range location, rbs_node_list_t *RBS_NONNULL types);

data/include/rbs/defines.h

@@ -69,9 +69,9 @@
  **********************************************************************************************************************/
 
 #if defined(_MSC_VER)
-#define NODISCARD _Check_return_
+#define RBS_NODISCARD _Check_return_
 #else
-#define NODISCARD __attribute__((warn_unused_result))
+#define RBS_NODISCARD __attribute__((warn_unused_result))
 #endif
 
 /**
@@ -87,8 +87,13 @@
  * Nullability annotations for pointer types.
  * Clang supports _Nullable and _Nonnull to indicate whether a pointer may be NULL.
  * On other compilers, these expand to nothing.
+ *
+ * They are Clang extensions, so a strict ISO C compilation rejects them with
+ * `-Wnullability-extension`, which is an error under `-pedantic-errors`. Expand
+ * them to nothing in that case, so that embedders compiling these headers with a
+ * conforming dialect (`-std=c99` and friends define `__STRICT_ANSI__`) still build.
  */
-#ifdef __clang__
+#if defined(__clang__) && !defined(__STRICT_ANSI__)
 #define RBS_NULLABLE _Nullable
 #define RBS_NONNULL _Nonnull
 #else

data/include/rbs/lexer.h

@@ -72,18 +72,19 @@ enum RBSTokenType {
     kRETURN,       /* return */
     kMODULESELF,   /* module-self */
 
-    tLIDENT,    /* Identifiers starting with lower case */
-    tUIDENT,    /* Identifiers starting with upper case */
-    tULIDENT,   /* Identifiers starting with `_` followed by upper case */
-    tULLIDENT,  /* Identifiers starting with `_` followed by lower case */
-    tGIDENT,    /* Identifiers starting with `$` */
-    tAIDENT,    /* Identifiers starting with `@` */
-    tA2IDENT,   /* Identifiers starting with `@@` */
-    tBANGIDENT, /* Identifiers ending with `!` */
-    tEQIDENT,   /* Identifiers ending with `=` */
-    tQIDENT,    /* Quoted identifier */
-    pAREF_OPR,  /* [] */
-    tOPERATOR,  /* Operator identifier */
+    tLIDENT,        /* Identifiers starting with lower case */
+    tUIDENT,        /* Identifiers starting with upper case */
+    tULIDENT,       /* Identifiers starting with `_` followed by upper case */
+    tULLIDENT,      /* Identifiers starting with `_` followed by lower case */
+    tNONASCIIIDENT, /* Identifiers starting with a character outside ASCII */
+    tGIDENT,        /* Identifiers starting with `$` */
+    tAIDENT,        /* Identifiers starting with `@` */
+    tA2IDENT,       /* Identifiers starting with `@@` */
+    tBANGIDENT,     /* Identifiers ending with `!` */
+    tEQIDENT,       /* Identifiers ending with `=` */
+    tQIDENT,        /* Quoted identifier */
+    pAREF_OPR,      /* [] */
+    tOPERATOR,      /* Operator identifier */
 
     tCOMMENT,       /* Comment */
     tLINECOMMENT,   /* Comment of all line */

data/include/rbs/parser.h

@@ -40,6 +40,21 @@ typedef struct rbs_error_t {
     bool syntax_error;
 } rbs_error_t;
 
+/**
+ * Options that control which syntax the parser accepts.
+ *
+ * Zero-initializing the struct gives the default configuration, where
+ * every optional syntax is disabled.
+ * */
+typedef struct {
+    /**
+     * Accept `(...)` forwarding parameters in method types.
+     *
+     * The syntax is experimental and disabled by default.
+     * */
+    bool enable_forwarding_params;
+} rbs_parser_options_t;
+
 /**
  * An RBS parser is a LL(3) parser.
  * */
@@ -57,6 +72,8 @@ typedef struct {
     rbs_constant_pool_t constant_pool;
     rbs_allocator_t *allocator;
     rbs_error_t *error;
+
+    rbs_parser_options_t options;
 } rbs_parser_t;
 
 /**
@@ -80,7 +97,7 @@ void rbs_parser_push_typevar_table(rbs_parser_t *parser, bool reset);
 /**
  * Insert new type variable into the latest table.
  * */
-NODISCARD bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id);
+RBS_NODISCARD bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id);
 
 /**
  * Allocate new rbs_lexer_t object.
@@ -89,8 +106,13 @@ NODISCARD bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t
  * VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
  * rbs_lexer_new(string, 0, 31)    // New rbs_lexer_t with buffer content
  * ```
+ *
+ * Returns `NULL` when `start_pos` is not the first byte of a character in
+ * `string` -- inside one, or past the end of the buffer. The lexer reaches
+ * `start_pos` a character at a time, so nowhere else is a position it can
+ * start from.
  * */
-rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+RBS_NODISCARD rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
 
 /**
  * Allocate new rbs_parser_t object.
@@ -98,8 +120,20 @@ rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string, const rbs_enc
  * ```
  * rbs_parser_new(buffer, string, encoding, 0, 1);
  * ```
+ *
+ * Returns `NULL` for a `start_pos` that `rbs_lexer_new` rejects.
+ * */
+RBS_NODISCARD rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+
+/**
+ * Allocate new rbs_parser_t object with the given options.
+ *
+ * `rbs_parser_new` is equivalent to passing a zero-initialized
+ * `rbs_parser_options_t`, which disables every optional syntax.
+ *
+ * Returns `NULL` for a `start_pos` that `rbs_lexer_new` rejects.
  * */
-rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+RBS_NODISCARD rbs_parser_t *rbs_parser_new_with_options(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos, rbs_parser_options_t options);
 void rbs_parser_free(rbs_parser_t *parser);
 
 /**

data/lib/rbs/ast/declarations.rb

@@ -163,7 +163,7 @@ module RBS
           alias eql? ==
 
           def hash
-            self.class.hash ^ name.hash ^ args.hash ^ location.hash
+            self.class.hash ^ name.hash ^ args.hash
           end
 
           def to_json(state = nil)

data/lib/rbs/ast/type_param.rb

@@ -114,7 +114,7 @@ module RBS
       def self.rename(params, new_names:)
         raise unless params.size == new_names.size
 
-        subst = Substitution.build(new_names, Types::Variable.build(new_names))
+        subst = Substitution.build(params.map(&:name), Types::Variable.build(new_names))
 
         params.map.with_index do |param, index|
           new_name = new_names[index]

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -179,7 +179,13 @@ module RBS
 
         super_types = with_super_classes.map do |decl|
           super_class = decl.super_class or raise
-          Types::ClassInstance.new(name: super_class.name, args: super_class.args, location: nil)
+          args = super_class.args
+
+          if align_params = entry.align_params(decl)
+            args = args.map {|type| type.sub(align_params) }
+          end
+
+          Types::ClassInstance.new(name: super_class.name, args: args, location: nil)
         end
 
         super_types.uniq!
@@ -473,10 +479,7 @@ module RBS
 
       def mixin_ancestors(entry, type_name, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
         entry.each_decl do |decl|
-          align_params = Substitution.build(
-            decl.type_params.each.map(&:name),
-            entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
-          )
+          align_params = entry.align_params(decl)
 
           mixin_ancestors0(decl,
                            type_name,

data/lib/rbs/definition_builder/method_builder.rb

@@ -104,7 +104,7 @@ module RBS
             type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
             Methods.new(type: type).tap do |methods|
               entry.each_decl do |decl|
-                subst = Substitution.build(decl.type_params.each.map(&:name), args)
+                subst = entry.align_params(decl)
                 case decl
                 when AST::Declarations::Base
                   each_rbs_member_with_accessibility(decl.members) do |member, accessibility|
@@ -115,14 +115,14 @@ module RBS
                         build_method(
                           methods,
                           type,
-                          member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
+                          member: subst ? member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }) : member,
                           accessibility: member.visibility || accessibility
                         )
                       when :singleton_instance
                         build_method(
                           methods,
                           type,
-                          member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
+                          member: subst ? member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }) : member,
                           accessibility: :private
                         )
                       end
@@ -130,7 +130,7 @@ module RBS
                       if member.kind == :instance
                         build_attribute(methods,
                                         type,
-                                        member: member.update(type: member.type.sub(subst)),
+                                        member: subst ? member.update(type: member.type.sub(subst)) : member,
                                         accessibility: member.visibility || accessibility)
                       end
                     when AST::Members::Alias

data/lib/rbs/definition_builder.rb

@@ -124,10 +124,13 @@ module RBS
       end
 
       entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
-      args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
 
       entry.each_decl do |decl|
-        subst_ = subst + Substitution.build(decl.type_params.each.map(&:name), args)
+        if align_params = entry.align_params(decl)
+          subst_ = subst + align_params
+        else
+          subst_ = subst
+        end
 
         decl.members.each do |member|
           case member

data/lib/rbs/environment/class_entry.rb

@@ -64,6 +64,18 @@ module RBS
           end
         end
       end
+
+      def align_params(decl)
+        entry_params = type_params
+        decl_param_names = decl.type_params.map(&:name)
+
+        return nil if decl_param_names == entry_params.map(&:name)
+
+        Substitution.build(
+          decl_param_names,
+          entry_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+        )
+      end
     end
   end
 end

data/lib/rbs/environment/module_entry.rb

@@ -42,10 +42,35 @@ module RBS
 
       def self_types
         each_decl.flat_map do |decl|
-          decl.self_types
+          self_types = decl.self_types
+          subst = align_params(decl)
+
+          if self_types.empty? || subst.nil?
+            self_types
+          else
+            self_types.map do |self_type|
+              AST::Declarations::Module::Self.new(
+                name: self_type.name,
+                args: self_type.args.map {|type| type.sub(subst) },
+                location: self_type.location
+              )
+            end
+          end
         end.uniq
       end
 
+      def align_params(decl)
+        entry_params = type_params
+        decl_param_names = decl.type_params.map(&:name)
+
+        return nil if decl_param_names == entry_params.map(&:name)
+
+        Substitution.build(
+          decl_param_names,
+          entry_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+        )
+      end
+
       def validate_type_params
         unless context_decls.empty?
           first_decl, *rest_decls = each_decl.to_a

data/lib/rbs/parser_aux.rb

@@ -14,7 +14,7 @@ module RBS
     def self.parse_method_type(source, range: nil, byte_range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
       byte_range = byte_range(range, buf.content) if range
-      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof)
+      _parse_method_type(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables, require_eof, false)
     end
 
     def self.parse_signature(source)
@@ -28,7 +28,7 @@ module RBS
           0
         end
       content = buf.content
-      dirs, decls = _parse_signature(buf, start_pos, content.bytesize)
+      dirs, decls = _parse_signature(buf, start_pos, content.bytesize, false)
 
       if resolved
         dirs = dirs.dup if dirs.frozen?

data/lib/rbs/prototype/helpers.rb

@@ -5,58 +5,25 @@ module RBS
     module Helpers
       private
 
-      # Prism can't parse Ruby 3.2 code
-      if RUBY_VERSION >= "3.3"
-        def parse_comments(string, include_trailing:)
-          Prism.parse_comments(string, version: "current").yield_self do |prism_comments| # steep:ignore UnexpectedKeywordArgument
-            prism_comments.each_with_object({}) do |comment, hash| #$ Hash[Integer, AST::Comment]
-              # Skip EmbDoc comments
-              next unless comment.is_a?(Prism::InlineComment)
-              # skip like `module Foo # :nodoc:`
-              next if comment.trailing? && !include_trailing
-
-              line = comment.location.start_line
-              body = "#{comment.location.slice}\n"
-              body = body[2..-1] or raise
-              body = "\n" if body.empty?
-
-              comment = AST::Comment.new(string: body, location: nil)
-              if prev_comment = hash.delete(line - 1)
-                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
-                                              location: nil)
-              else
-                hash[line] = comment
-              end
-            end
-          end
-        end
-      else
-        require "ripper"
-        def parse_comments(string, include_trailing:)
-          Ripper.lex(string).yield_self do |tokens|
-            code_lines = {} #: Hash[Integer, bool]
-            tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
-              case token[1]
-              when :on_sp, :on_ignored_nl
-                # skip
-              when :on_comment
-                line = token[0][0]
-                # skip like `module Foo # :nodoc:`
-                next if code_lines[line] && !include_trailing
-                body = token[2][2..-1] or raise
-
-                body = "\n" if body.empty?
-
-                comment = AST::Comment.new(string: body, location: nil)
-                if prev_comment = hash.delete(line - 1)
-                  hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
-                                                location: nil)
-                else
-                  hash[line] = comment
-                end
-              else
-                code_lines[token[0][0]] = true
-              end
+      def parse_comments(string, include_trailing:)
+        Prism.parse_comments(string, version: "current").yield_self do |prism_comments| # steep:ignore UnexpectedKeywordArgument
+          prism_comments.each_with_object({}) do |comment, hash| #$ Hash[Integer, AST::Comment]
+            # Skip EmbDoc comments
+            next unless comment.is_a?(Prism::InlineComment)
+            # skip like `module Foo # :nodoc:`
+            next if comment.trailing? && !include_trailing
+
+            line = comment.location.start_line
+            body = "#{comment.location.slice}\n"
+            body = body[2..-1] or raise
+            body = "\n" if body.empty?
+
+            comment = AST::Comment.new(string: body, location: nil)
+            if prev_comment = hash.delete(line - 1)
+              hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                            location: nil)
+            else
+              hash[line] = comment
             end
           end
         end

data/lib/rbs/prototype/runtime/value_object_generator.rb

@@ -212,7 +212,6 @@ module RBS
 
       class DataGenerator < ValueObjectBase
         def self.generatable?(target)
-          return false unless RUBY_VERSION >= '3.2'
           return false unless target < Data
           # Avoid direct inherited class like `class Option < Data`
           return false unless target.respond_to?(:members)

data/lib/rbs/prototype/runtime.rb

@@ -527,7 +527,7 @@ module RBS
 
         generate_mixin(mod, decl, type_name, type_name_absolute)
 
-        unless mod < Struct || (RUBY_VERSION >= '3.2' && mod < Data)
+        unless mod < Struct || mod < Data
           generate_methods(mod, type_name, decl.members) unless outline
         end
 

data/lib/rbs/types.rb

@@ -959,6 +959,33 @@ module RBS
         end
       end
 
+      class ForwardingParam
+        attr_reader :location
+
+        def initialize(location:)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(ForwardingParam)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+
+        def to_json(state = nil)
+          json = {} #: Hash[Symbol, untyped]
+          json.to_json(state)
+        end
+
+        def to_s
+          "..."
+        end
+      end
+
       attr_reader :required_positionals
       attr_reader :optional_positionals
       attr_reader :rest_positionals
@@ -966,9 +993,10 @@ module RBS
       attr_reader :required_keywords
       attr_reader :optional_keywords
       attr_reader :rest_keywords
+      attr_reader :forwarding
       attr_reader :return_type
 
-      def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:)
+      def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:, forwarding: nil)
         @return_type = return_type
         @required_positionals = required_positionals
         @optional_positionals = optional_positionals
@@ -977,6 +1005,7 @@ module RBS
         @required_keywords = required_keywords
         @optional_keywords = optional_keywords
         @rest_keywords = rest_keywords
+        @forwarding = forwarding
       end
 
       def ==(other)
@@ -988,6 +1017,7 @@ module RBS
           other.required_keywords == required_keywords &&
           other.optional_keywords == optional_keywords &&
           other.rest_keywords == rest_keywords &&
+          other.forwarding == forwarding &&
           other.return_type == return_type
       end
 
@@ -1002,6 +1032,7 @@ module RBS
           required_keywords.hash ^
           optional_keywords.hash ^
           rest_keywords.hash ^
+          forwarding.hash ^
           return_type.hash
       end
 
@@ -1043,6 +1074,7 @@ module RBS
             required_keywords: hmapv(required_keywords) {|param| param.map_type(&block) },
             optional_keywords: hmapv(optional_keywords) {|param| param.map_type(&block) },
             rest_keywords: rest_keywords&.yield_self {|param| param.map_type(&block) },
+            forwarding: forwarding,
             return_type: yield(return_type)
           )
         else
@@ -1110,6 +1142,7 @@ module RBS
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: return_type
         }.to_json(state)
       end
@@ -1129,6 +1162,7 @@ module RBS
           required_keywords: {},
           optional_keywords: {},
           rest_keywords: nil,
+          forwarding: nil,
           return_type: return_type
         )
       end
@@ -1142,12 +1176,13 @@ module RBS
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: type
         )
       end
 
       def update(required_positionals: self.required_positionals, optional_positionals: self.optional_positionals, rest_positionals: self.rest_positionals, trailing_positionals: self.trailing_positionals,
-                 required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords, return_type: self.return_type)
+                 required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords, forwarding: self.forwarding, return_type: self.return_type)
         Function.new(
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -1156,6 +1191,7 @@ module RBS
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
+          forwarding: forwarding,
           return_type: return_type
         )
       end
@@ -1167,6 +1203,7 @@ module RBS
           trailing_positionals.empty? &&
           required_keywords.empty? &&
           optional_keywords.empty? &&
+          !forwarding? &&
           !rest_keywords
       end
 
@@ -1175,6 +1212,7 @@ module RBS
         params = []
 
         params.push(*required_positionals.map(&:to_s))
+        params.push(forwarding.to_s) if forwarding
         params.push(*optional_positionals.map {|p| "?#{p}"})
         params.push("*#{rest_positionals}") if rest_positionals
         params.push(*trailing_positionals.map(&:to_s))
@@ -1185,6 +1223,10 @@ module RBS
         params.join(", ")
       end
 
+      def forwarding?
+        !forwarding.nil?
+      end
+
       def return_to_s
         return_type.to_s(1)
       end