rbs 4.1.2-java → 4.2.0-java

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

data/lib/rbs/unit_test/type_assertions.rb

@@ -180,11 +180,11 @@ module RBS
           )
           errors = typecheck.method_call(method, method_type, trace, errors: [])
 
-          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, -> { "Call trace does not match with given method type: #{trace.inspect}" }
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.any? {|es| es.empty? }, -> { "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           raise exception if exception
 
@@ -204,11 +204,11 @@ module RBS
           )
           errors = typecheck.method_call(method, method_type, trace, errors: [])
 
-          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, -> { "Call trace does not match with given method type: #{trace.inspect}" }
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.any? {|es| es.empty? }, -> { "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           # Use `instnace_of?` instead of `is_a?` as we want to check for _the exact exception class_.
           assert exception.instance_of? error_type
@@ -246,7 +246,7 @@ module RBS
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.all? {|es| es.size > 0 }, -> { "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           result
         end

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "4.1.2"
+  VERSION = "4.2.0"
 end