rbs 4.1.3-java → 4.2.0-java

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/version.rb

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

data/lib/rbs/wasm/parser.rb

@@ -12,83 +12,102 @@ module RBS
   # RBS::Parser API on top, exactly as it does for the C extension.
   class Parser
     class << self
-      def _parse_signature(buffer, start_pos, end_pos)
-        validate_position_range(start_pos, end_pos)
+      def _parse_signature(buffer, start_pos, end_pos, enable_forwarding_params)
+        validate_position_range(buffer, start_pos, end_pos)
+        validate_parser_options(enable_forwarding_params)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_signature(buffer.content, encoding, start_pos, end_pos)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_signature(buffer.content, encoding, start_pos, end_pos)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         WASM::Deserializer.deserialize(bytes, buffer)
       end
 
       def _parse_type(buffer, start_pos, end_pos, variables, require_eof, void_allowed, self_allowed, classish_allowed)
-        validate_position_range(start_pos, end_pos)
+        validate_position_range(buffer, start_pos, end_pos)
         validate_variables(variables)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_type(buffer.content, encoding, start_pos, end_pos, variables, require_eof, void_allowed, self_allowed, classish_allowed)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_type(buffer.content, encoding, start_pos, end_pos, variables, require_eof, void_allowed, self_allowed, classish_allowed)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         deserialize_or_nil(bytes, buffer)
       end
 
-      def _parse_method_type(buffer, start_pos, end_pos, variables, require_eof)
-        validate_position_range(start_pos, end_pos)
+      def _parse_method_type(buffer, start_pos, end_pos, variables, require_eof, enable_forwarding_params)
+        validate_position_range(buffer, start_pos, end_pos)
         validate_variables(variables)
+        validate_parser_options(enable_forwarding_params)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_method_type(buffer.content, encoding, start_pos, end_pos, variables, require_eof)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_method_type(buffer.content, encoding, start_pos, end_pos, variables, require_eof)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         deserialize_or_nil(bytes, buffer)
       end
 
       def _parse_type_params(buffer, start_pos, end_pos, module_type_params)
-        validate_position_range(start_pos, end_pos)
+        validate_position_range(buffer, start_pos, end_pos)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_type_params(buffer.content, encoding, start_pos, end_pos, module_type_params)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_type_params(buffer.content, encoding, start_pos, end_pos, module_type_params)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         bytes.empty? ? nil : WASM::Deserializer.deserialize_node_list(bytes, buffer)
       end
 
       def _lex(buffer, end_pos)
         encoding = buffer.content.encoding.name
-        _success, bytes = WASM::Runtime.instance.lex(buffer.content, encoding, end_pos)
+        _status, bytes = WASM::Runtime.instance.lex(buffer.content, encoding, end_pos)
 
         WASM::Deserializer.deserialize_tokens(bytes, buffer)
       end
 
       def _parse_inline_leading_annotation(buffer, start_pos, end_pos, variables)
-        validate_position_range(start_pos, end_pos)
+        validate_position_range(buffer, start_pos, end_pos)
         validate_variables(variables)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_inline_leading_annotation(buffer.content, encoding, start_pos, end_pos, variables)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_inline_leading_annotation(buffer.content, encoding, start_pos, end_pos, variables)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         deserialize_or_nil(bytes, buffer)
       end
 
       def _parse_inline_trailing_annotation(buffer, start_pos, end_pos, variables)
-        validate_position_range(start_pos, end_pos)
+        validate_position_range(buffer, start_pos, end_pos)
         validate_variables(variables)
         encoding = buffer.content.encoding.name
-        success, bytes = WASM::Runtime.instance.parse_inline_trailing_annotation(buffer.content, encoding, start_pos, end_pos, variables)
-        raise_parsing_error(buffer, bytes) unless success
+        status, bytes = WASM::Runtime.instance.parse_inline_trailing_annotation(buffer.content, encoding, start_pos, end_pos, variables)
+        raise_parse_failure(buffer, status, bytes, start_pos, end_pos) unless status == WASM::Runtime::OK
 
         deserialize_or_nil(bytes, buffer)
       end
 
       private
 
-      # Reject negative or reversed ranges before handing them to the parser,
-      # matching validate_position_range in the C extension (main.c). A reversed
-      # range would otherwise make the lexer loop forever inside WebAssembly.
-      def validate_position_range(start_pos, end_pos)
+      # Reject the position ranges the parser cannot take, matching
+      # validate_position_range in the C extension (main.c).
+      #
+      # `end_pos` past the end of the buffer is fine: clamping with a large
+      # number instead of measuring the buffer is ordinary, and the lexer stops
+      # at the end of the input on its own.
+      def validate_position_range(buffer, start_pos, end_pos)
         if start_pos < 0 || end_pos < 0
           raise ArgumentError, "negative position range: #{start_pos}...#{end_pos}"
         end
         if start_pos > end_pos
           raise ArgumentError, "invalid position range: #{start_pos}...#{end_pos}"
         end
+
+        size = buffer.content.bytesize
+        if start_pos > size
+          raise ArgumentError, "position range starts past the end of the buffer: #{start_pos}...#{end_pos}, buffer is #{size} bytes"
+        end
+      end
+
+      # The WebAssembly entry points (rbs_wasm.c) build their parsers with the
+      # default options, so the optional syntax the C extension can enable is
+      # not reachable here. The public RBS::Parser API never enables it.
+      def validate_parser_options(enable_forwarding_params)
+        if enable_forwarding_params
+          raise NotImplementedError, "forwarding parameter syntax is not supported by the WebAssembly parser"
+        end
       end
 
       # Reject anything that is not nil or an Array of Symbols, matching
@@ -112,6 +131,24 @@ module RBS
         bytes.empty? ? nil : WASM::Deserializer.deserialize(bytes, buffer)
       end
 
+      # Raise for a status other than OK (see rbs_wasm.c).
+      #
+      # A negative status is about the range rather than the source text, so it
+      # comes with an empty result and an ArgumentError, as in the C extension
+      # (main.c). Starting past the end of the buffer is plain from the
+      # buffer's size and rejected above, so a start position that comes back
+      # rejected can only be one inside a character.
+      def raise_parse_failure(buffer, status, bytes, start_pos, end_pos)
+        case status
+        when WASM::Runtime::INVALID_START_POS
+          raise ArgumentError, "position range starts inside a character: #{start_pos}...#{end_pos}"
+        when WASM::Runtime::INVALID_RANGE
+          raise ArgumentError, "invalid position range: #{start_pos}...#{end_pos}"
+        else
+          raise_parsing_error(buffer, bytes)
+        end
+      end
+
       # Decodes the error blob written by set_error_result (rbs_wasm.c) and raises
       # the same error the C extension would (see raise_error in main.c).
       def raise_parsing_error(buffer, blob)

data/lib/rbs/wasm/runtime.rb

@@ -16,6 +16,14 @@ module RBS
     class Runtime
       include MonitorMixin
 
+      # Statuses the parse entry points return (see rbs_wasm.c). A negative one
+      # is about the range the caller asked for rather than the source text,
+      # and comes with an empty result.
+      INVALID_START_POS = -2
+      INVALID_RANGE = -1
+      PARSE_ERROR = 0
+      OK = 1
+
       class << self
         def instance
           @instance ||= new
@@ -48,9 +56,9 @@ module RBS
       end
 
       # `content` is the whole buffer; `start_pos`/`end_pos` are the character
-      # range within it to parse. Each method returns [success, bytes]: on success
-      # `bytes` is the serialized AST, otherwise it is the error blob (see
-      # set_error_result in rbs_wasm.c).
+      # range within it to parse. Each method returns [status, bytes]: with OK
+      # `bytes` is the serialized AST, with PARSE_ERROR it is the error blob (see
+      # set_error_result in rbs_wasm.c), and with a negative status it is empty.
 
       def parse_signature(content, encoding, start_pos, end_pos)
         run(content, encoding) { |ptr, len, enc_ptr, enc_len| @parse_signature.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos)[0] }
@@ -118,7 +126,7 @@ module RBS
             @memory.write(source_ptr, bytes.to_java_bytes)
             @memory.write(name_ptr, name.to_java_bytes) unless name_length.zero?
             status = yield(source_ptr, length, name_ptr, name_length)
-            [status == 1, read_result]
+            [i32(status), read_result]
           ensure
             @free.apply(source_ptr)
             @free.apply(name_ptr)
@@ -156,6 +164,13 @@ module RBS
         end
       end
 
+      # A WebAssembly i32 comes back in a JVM long, so read the low 32 bits as
+      # signed: the negative statuses have to stay negative on this side.
+      def i32(value)
+        value &= 0xFFFF_FFFF
+        value >= 0x8000_0000 ? value - 0x1_0000_0000 : value
+      end
+
       def bool(value)
         value ? 1 : 0
       end

data/lib/rbs/wasm/serialization_schema.rb

@@ -23,7 +23,7 @@ module RBS
     # :bool, :location_range, :location_range_list, :attr_ivar_name, or
     # [:enum, [value_or_nil, ...]].
     module SerializationSchema
-      SYMBOL_TAG = 78
+      SYMBOL_TAG = 79
 
       SCHEMA = [
         nil, # tag 0 is reserved for NULL
@@ -91,7 +91,8 @@ module RBS
         [:node, "RBS::Types::Block", true, nil, [[:type, :node], [:required, :bool], [:self_type, :node]], false],
         [:node, "RBS::Types::ClassInstance", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
         [:node, "RBS::Types::ClassSingleton", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
-        [:node, "RBS::Types::Function", false, nil, [[:required_positionals, :node_list], [:optional_positionals, :node_list], [:rest_positionals, :node], [:trailing_positionals, :node_list], [:required_keywords, :hash], [:optional_keywords, :hash], [:rest_keywords, :node], [:return_type, :node]], false],
+        [:node, "RBS::Types::Function", false, nil, [[:required_positionals, :node_list], [:optional_positionals, :node_list], [:rest_positionals, :node], [:trailing_positionals, :node_list], [:required_keywords, :hash], [:optional_keywords, :hash], [:rest_keywords, :node], [:forwarding, :node], [:return_type, :node]], false],
+        [:node, "RBS::Types::Function::ForwardingParam", true, nil, nil, false],
         [:node, "RBS::Types::Function::Param", true, [[:name, false]], [[:type, :node], [:name, :node]], false],
         [:node, "RBS::Types::Interface", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
         [:node, "RBS::Types::Intersection", true, nil, [[:types, :node_list]], false],

data/rbs.gemspec

@@ -67,14 +67,10 @@ Gem::Specification.new do |spec|
     spec.extensions = %w{ext/rbs_extension/extconf.rb}
   end
 
-  if false
-    spec.required_ruby_version = ">= 3.4"
-  end
-
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.2"
+  spec.required_ruby_version = ">= 3.3"
   spec.add_dependency "logger"
   spec.add_dependency "prism", ">= 1.6.0"
   spec.add_dependency "tsort"

data/schema/function.json

@@ -78,10 +78,21 @@
         }
       ]
     },
+    "forwarding": {
+      "title": "Forwarding parameter",
+      "oneOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "return_type": {
       "title": "Return type of a function",
       "$ref": "types.json"
     }
   },
-  "required": ["required_positionals", "optional_positionals", "rest_positionals", "trailing_positionals", "required_keywords", "optional_keywords", "rest_keywords", "return_type"]
+  "required": ["required_positionals", "optional_positionals", "rest_positionals", "trailing_positionals", "required_keywords", "optional_keywords", "rest_keywords", "forwarding", "return_type"]
 }

data/sig/environment/class_entry.rbs

@@ -45,6 +45,12 @@ module RBS
       # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
       #
       def validate_type_params: () -> void
+
+      # Returns a substitution that renames the type parameters of the declaration to the entry's type parameters (`#type_params`)
+      #
+      # Returns `nil` if the declaration uses the same type parameter names as `#type_params`.
+      #
+      def align_params: (declaration | ModuleEntry::declaration) -> Substitution?
     end
   end
 end

data/sig/environment/module_entry.rbs

@@ -44,7 +44,22 @@ module RBS
       #
       def validate_type_params: () -> void
 
+      # Returns the self types of the declarations
+      #
+      # The type variables in the self types are aligned to `#type_params`,
+      # so that the self types from declarations with different type parameter
+      # names can be compared and used with `#type_params`.
+      #
+      # Note that the returned objects may be different from the ones in the
+      # declarations, but `#location` points to the original declaration.
+      #
       def self_types: () -> Array[AST::Declarations::Module::Self]
+
+      # Returns a substitution that renames the type parameters of the declaration to the entry's type parameters (`#type_params`)
+      #
+      # Returns `nil` if the declaration uses the same type parameter names as `#type_params`.
+      #
+      def align_params: (declaration | ClassEntry::declaration) -> Substitution?
     end
   end
 end