rbs 4.1.2-java → 4.2.0-java

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

data/sig/parser.rbs

@@ -136,9 +136,9 @@ module RBS
 
     def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> Types::t?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool enable_forwarding_params) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos, bool enable_forwarding_params) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     # Parse and serialize the result to the binary format consumed by
     # RBS::WASM::Deserializer (see ext/rbs_extension/main.c and
@@ -146,9 +146,9 @@ module RBS
     # round-trip can be exercised on CRuby.
     def self._parse_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> String?
 
-    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> String?
+    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool enable_forwarding_params) -> String?
 
-    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos) -> String
+    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos, bool enable_forwarding_params) -> String
 
     def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
 

data/sig/types.rbs

@@ -385,6 +385,12 @@ module RBS
                     | -> Enumerator[t, Param]
       end
 
+      class ForwardingParam
+        attr_reader location: Location?
+
+        def initialize: (location: Location) -> void
+      end
+
       attr_reader required_positionals: Array[Param]
       attr_reader optional_positionals: Array[Param]
       attr_reader rest_positionals: Param?
@@ -392,6 +398,7 @@ module RBS
       attr_reader required_keywords: Hash[Symbol, Param]
       attr_reader optional_keywords: Hash[Symbol, Param]
       attr_reader rest_keywords: Param?
+      attr_reader forwarding: ForwardingParam?
       attr_reader return_type: t
 
       def initialize: (required_positionals: Array[Param],
@@ -401,7 +408,8 @@ module RBS
                        required_keywords: Hash[Symbol, Param],
                        optional_keywords: Hash[Symbol, Param],
                        rest_keywords: Param?,
-                       return_type: t) -> void
+                       return_type: t,
+                       ?forwarding: ForwardingParam?) -> void
 
       def free_variables: (?Set[Symbol]) -> Set[Symbol]
 
@@ -431,9 +439,11 @@ module RBS
                    ?required_keywords: Hash[Symbol, Param],
                    ?optional_keywords: Hash[Symbol, Param],
                    ?rest_keywords: Param?,
+                   ?forwarding: ForwardingParam?,
                    ?return_type: t) -> Function
 
       def empty?: () -> bool
+      def forwarding?: () -> bool
 
       def param_to_s: () -> String
       def return_to_s: () -> String

data/sig/unit_test/type_assertions.rbs

@@ -30,11 +30,11 @@ module RBS
       type target_type = Types::ClassInstance | Types::ClassSingleton
 
       interface _BaseAssertions
-        def assert: (untyped, ?String?) -> void
+        def assert: (untyped, ?(String | ^() -> String)?) -> void
 
         def refute: (untyped, ?String?) -> void
 
-        def assert_empty: (untyped, ?String?) -> void
+        def assert_empty: (untyped, ?(String | ^() -> String)?) -> void
 
         def assert_operator: (untyped, Symbol, *untyped) -> void
 

data/src/ast.c

@@ -143,6 +143,8 @@ const char *RBS_NONNULL rbs_node_type_name(rbs_node_t *RBS_NONNULL node) {
         return "RBS::Types::ClassSingleton";
     case RBS_TYPES_FUNCTION:
         return "RBS::Types::Function";
+    case RBS_TYPES_FUNCTION_FORWARDING_PARAM:
+        return "RBS::Types::Function::ForwardingParam";
     case RBS_TYPES_FUNCTION_PARAM:
         return "RBS::Types::Function::Param";
     case RBS_TYPES_INTERFACE:
@@ -1430,7 +1432,7 @@ rbs_types_class_singleton_t *RBS_NONNULL rbs_types_class_singleton_new(rbs_alloc
     return instance;
 }
 #line 140 "templates/src/ast.c.erb"
-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_t *instance = rbs_allocator_alloc(allocator, rbs_types_function_t);
 
     *instance = (rbs_types_function_t) {
@@ -1445,12 +1447,26 @@ rbs_types_function_t *RBS_NONNULL rbs_types_function_new(rbs_allocator_t *RBS_NO
         .required_keywords = required_keywords,
         .optional_keywords = optional_keywords,
         .rest_keywords = rest_keywords,
+        .forwarding = forwarding,
         .return_type = return_type,
     };
 
     return instance;
 }
 #line 140 "templates/src/ast.c.erb"
+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_forwarding_param_t *instance = rbs_allocator_alloc(allocator, rbs_types_function_forwarding_param_t);
+
+    *instance = (rbs_types_function_forwarding_param_t) {
+        .base = (rbs_node_t) {
+            .type = RBS_TYPES_FUNCTION_FORWARDING_PARAM,
+            .location = location,
+        },
+    };
+
+    return instance;
+}
+#line 140 "templates/src/ast.c.erb"
 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_function_param_t *instance = rbs_allocator_alloc(allocator, rbs_types_function_param_t);