rbs 4.0.3 → 4.1.3

data/lib/rbs/wasm/parser.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "runtime"
+require_relative "deserializer"
+
+module RBS
+  # WebAssembly-backed implementation of the parser primitives.
+  #
+  # On CRuby these come from the C extension (ext/rbs_extension/main.c). JRuby
+  # loads this instead: it runs the parser inside WebAssembly, then rebuilds the
+  # AST with RBS::WASM::Deserializer. rbs/parser_aux.rb layers the public
+  # 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)
+        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
+
+        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_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
+
+        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)
+        validate_variables(variables)
+        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
+
+        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)
+        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
+
+        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)
+
+        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_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
+
+        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_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
+
+        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)
+        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
+      end
+
+      # Reject anything that is not nil or an Array of Symbols, matching
+      # declare_type_variables in the C extension (main.c).
+      def validate_variables(variables)
+        return if variables.nil?
+
+        unless variables.is_a?(Array)
+          raise TypeError, "wrong argument type #{variables.class} (must be an Array of Symbols or nil)"
+        end
+
+        variables.each do |variable|
+          unless variable.is_a?(Symbol)
+            raise TypeError, "Type variables Array contains invalid value #{variable.inspect} of type #{variable.class} (must be an Array of Symbols or nil)"
+          end
+        end
+      end
+
+      # An empty result means the parser reached EOF immediately (`nil`).
+      def deserialize_or_nil(bytes, buffer)
+        bytes.empty? ? nil : WASM::Deserializer.deserialize(bytes, buffer)
+      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)
+        start_char, end_char, syntax_error = blob.unpack("l<l<C")
+
+        raise "Unexpected error" if syntax_error.zero?
+
+        offset = 9
+        token_type_length = blob.unpack1("L<", offset: offset)
+        offset += 4
+        token_type = blob.byteslice(offset, token_type_length).to_s.force_encoding(Encoding::UTF_8)
+        offset += token_type_length
+
+        message_length = blob.unpack1("L<", offset: offset)
+        offset += 4
+        message = blob.byteslice(offset, message_length).to_s.force_encoding(Encoding::UTF_8)
+
+        location = Location.new(buffer, start_char, end_char)
+        raise ParsingError.new(location, message, token_type)
+      end
+    end
+  end
+end

data/lib/rbs/wasm/runtime.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "java"
+require "monitor"
+
+module RBS
+  module WASM
+    # Loads rbs_parser.wasm into a JVM WebAssembly runtime (Chicory) and drives
+    # it. This is the JRuby counterpart of the C extension's main.c: it copies a
+    # source string into the module's linear memory, runs the parser, and returns
+    # the serialized result for RBS::WASM::Deserializer to rebuild.
+    #
+    # Chicory is a pure-Java runtime, so there is no native dependency. The
+    # `.wasm` ships in the gem; the Chicory jars are fetched from Maven by
+    # jar-dependencies (see lib/rbs_jars.rb and rbs.gemspec).
+    class Runtime
+      include MonitorMixin
+
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        def wasm_path
+          ENV["RBS_WASM_PARSER"] || File.expand_path("rbs_parser.wasm", __dir__)
+        end
+      end
+
+      def initialize
+        super()
+        # rbs_jars.rb require_jars the Chicory/ASM jars from the local Maven
+        # repository (~/.m2), where jar-dependencies puts them at gem install (or
+        # `rake wasm:install_jars` when running from source).
+        require "rbs_jars"
+        @wasm = build_instance
+        @memory = @wasm.memory
+        @alloc = @wasm.export("rbs_wasm_alloc")
+        @free = @wasm.export("rbs_wasm_free")
+        @result_ptr = @wasm.export("rbs_wasm_result_ptr")
+        @result_len = @wasm.export("rbs_wasm_result_len")
+        @parse_signature = @wasm.export("rbs_wasm_parse_signature")
+        @parse_type = @wasm.export("rbs_wasm_parse_type")
+        @parse_method_type = @wasm.export("rbs_wasm_parse_method_type")
+        @parse_type_params = @wasm.export("rbs_wasm_parse_type_params")
+        @parse_inline_leading_annotation = @wasm.export("rbs_wasm_parse_inline_leading_annotation")
+        @parse_inline_trailing_annotation = @wasm.export("rbs_wasm_parse_inline_trailing_annotation")
+        @lex = @wasm.export("rbs_wasm_lex")
+      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).
+
+      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] }
+      end
+
+      def parse_type(content, encoding, start_pos, end_pos, variables, require_eof, void_allowed, self_allowed, classish_allowed)
+        with_variables(variables) do |vars_ptr, vars_len|
+          run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+            @parse_type.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos, vars_ptr, vars_len, bool(require_eof), bool(void_allowed), bool(self_allowed), bool(classish_allowed))[0]
+          end
+        end
+      end
+
+      def parse_method_type(content, encoding, start_pos, end_pos, variables, require_eof)
+        with_variables(variables) do |vars_ptr, vars_len|
+          run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+            @parse_method_type.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos, vars_ptr, vars_len, bool(require_eof))[0]
+          end
+        end
+      end
+
+      def parse_type_params(content, encoding, start_pos, end_pos, module_type_params)
+        run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+          @parse_type_params.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos, bool(module_type_params))[0]
+        end
+      end
+
+      def parse_inline_leading_annotation(content, encoding, start_pos, end_pos, variables)
+        with_variables(variables) do |vars_ptr, vars_len|
+          run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+            @parse_inline_leading_annotation.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos, vars_ptr, vars_len)[0]
+          end
+        end
+      end
+
+      def parse_inline_trailing_annotation(content, encoding, start_pos, end_pos, variables)
+        with_variables(variables) do |vars_ptr, vars_len|
+          run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+            @parse_inline_trailing_annotation.apply(ptr, len, enc_ptr, enc_len, start_pos, end_pos, vars_ptr, vars_len)[0]
+          end
+        end
+      end
+
+      def lex(content, encoding, end_pos)
+        run(content, encoding) do |ptr, len, enc_ptr, enc_len|
+          @lex.apply(ptr, len, enc_ptr, enc_len, end_pos)[0]
+        end
+      end
+
+      private
+
+      # Copies `source` and its encoding name into linear memory, yields their
+      # pointers/lengths to the block (which invokes the parser and returns its
+      # status), then reads the result back out. Serialized through the monitor
+      # because the module keeps its result in a single shared location.
+      def run(source, encoding)
+        synchronize do
+          bytes = source.b
+          length = bytes.bytesize
+          name = encoding.to_s.b
+          name_length = name.bytesize
+          source_ptr = @alloc.apply(length)[0]
+          name_ptr = @alloc.apply(name_length)[0]
+          begin
+            @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]
+          ensure
+            @free.apply(source_ptr)
+            @free.apply(name_ptr)
+          end
+        end
+      end
+
+      def read_result
+        pointer = @result_ptr.apply[0]
+        length = @result_len.apply[0]
+        return "".b if length.zero?
+
+        String.from_java_bytes(@memory.read_bytes(pointer, length)).b
+      end
+
+      # Allocates a buffer of newline-separated variable names and yields its
+      # pointer/length. A nil `variables` is passed as length -1 ("no variables").
+      def with_variables(variables)
+        names = variables&.map(&:to_s)&.join("\n")
+
+        if names.nil? || names.empty?
+          return yield(0, variables.nil? ? -1 : 0)
+        end
+
+        bytes = names.b
+        length = bytes.bytesize
+        synchronize do
+          pointer = @alloc.apply(length)[0]
+          begin
+            @memory.write(pointer, bytes.to_java_bytes)
+            yield(pointer, length)
+          ensure
+            @free.apply(pointer)
+          end
+        end
+      end
+
+      def bool(value)
+        value ? 1 : 0
+      end
+
+      def build_instance
+        parser = Java::ComDylibsoChicoryWasm::Parser
+        instance_class = Java::ComDylibsoChicoryRuntime::Instance
+        import_values = Java::ComDylibsoChicoryRuntime::ImportValues
+        wasi_preview1 = Java::ComDylibsoChicoryWasi::WasiPreview1
+        wasi_options = Java::ComDylibsoChicoryWasi::WasiOptions
+
+        wasm_module = parser.parse(java.io.File.new(self.class.wasm_path))
+        wasi = wasi_preview1.builder.with_options(wasi_options.builder.build).build
+        imports = import_values.builder.add_function(wasi.to_host_functions).build
+
+        builder = instance_class.builder(wasm_module).with_import_values(imports)
+        if (factory = machine_factory(wasm_module))
+          builder = builder.with_machine_factory(factory)
+        end
+
+        wasm = builder.build
+        wasm.export("_initialize").apply
+        wasm
+      end
+
+      # Chicory's AOT compiler when its jars are present and usable, otherwise nil
+      # (the builder then uses the interpreter). NameError covers a missing
+      # compiler class; LinkageError covers an incompatible/missing ASM (so a bad
+      # jar set degrades to the interpreter instead of crashing).
+      def machine_factory(wasm_module)
+        Java::ComDylibsoChicoryCompiler::MachineFactoryCompiler.compile(wasm_module)
+      rescue NameError, Java::JavaLang::LinkageError
+        nil
+      end
+
+    end
+  end
+end

data/lib/rbs/wasm/serialization_schema.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+#
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. To change the template see
+#   templates/lib/rbs/wasm/serialization_schema.rb.erb
+
+module RBS
+  module WASM
+    # Describes how to decode the binary buffer produced by `rbs_serialize_node`
+    # (src/serialize.c) back into RBS::AST objects. RBS::WASM::Deserializer walks
+    # this table; the matching encoder is generated from the same config.yml, so
+    # the two stay in sync.
+    #
+    # SCHEMA is indexed by node tag: tag 0 is NULL and SYMBOL_TAG is the
+    # interned-symbol tag. Each remaining entry is one of:
+    #
+    #   [:node, class_name, expose_location, loc_children, fields, resolve_type_params]
+    #   [:bool] / [:integer] / [:string_value] / [:record_field]
+    #   [:signature] / [:namespace] / [:type_name]
+    #
+    # where loc_children is [[name, required?], ...] and fields is
+    # [[name, reader], ...] with reader one of :node, :node_list, :hash, :string,
+    # :bool, :location_range, :location_range_list, :attr_ivar_name, or
+    # [:enum, [value_or_nil, ...]].
+    module SerializationSchema
+      SYMBOL_TAG = 78
+
+      SCHEMA = [
+        nil, # tag 0 is reserved for NULL
+        [:node, "RBS::AST::Annotation", true, nil, [[:string, :string]], false],
+        [:bool],
+        [:node, "RBS::AST::Comment", true, nil, [[:string, :string]], false],
+        [:node, "RBS::AST::Declarations::Class", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false], [:lt, false]], [[:name, :node], [:type_params, :node_list], [:super_class, :node], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Class::Super", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::AST::Declarations::ClassAlias", true, [[:keyword, true], [:new_name, true], [:eq, true], [:old_name, true]], [[:new_name, :node], [:old_name, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Constant", true, [[:name, true], [:colon, true]], [[:name, :node], [:type, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Global", true, [[:name, true], [:colon, true]], [[:name, :node], [:type, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::Interface", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false]], [[:name, :node], [:type_params, :node_list], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Module", true, [[:keyword, true], [:name, true], [:end, true], [:type_params, false], [:colon, false], [:self_types, false]], [[:name, :node], [:type_params, :node_list], [:self_types, :node_list], [:members, :node_list], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Declarations::Module::Self", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::AST::Declarations::ModuleAlias", true, [[:keyword, true], [:new_name, true], [:eq, true], [:old_name, true]], [[:new_name, :node], [:old_name, :node], [:comment, :node], [:annotations, :node_list]], false],
+        [:node, "RBS::AST::Declarations::TypeAlias", true, [[:keyword, true], [:name, true], [:eq, true], [:type_params, false]], [[:name, :node], [:type_params, :node_list], [:type, :node], [:annotations, :node_list], [:comment, :node]], true],
+        [:node, "RBS::AST::Directives::Use", true, [[:keyword, true]], [[:clauses, :node_list]], false],
+        [:node, "RBS::AST::Directives::Use::SingleClause", true, [[:type_name, true], [:keyword, false], [:new_name, false]], [[:type_name, :node], [:new_name, :node]], false],
+        [:node, "RBS::AST::Directives::Use::WildcardClause", true, [[:namespace, true], [:star, true]], [[:namespace, :node]], false],
+        [:integer],
+        [:node, "RBS::AST::Members::Alias", true, [[:keyword, true], [:new_name, true], [:old_name, true], [:new_kind, false], [:old_kind, false]], [[:new_name, :node], [:old_name, :node], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::AttrAccessor", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::AttrReader", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::AttrWriter", true, [[:keyword, true], [:name, true], [:colon, true], [:kind, false], [:ivar, false], [:ivar_name, false], [:visibility, false]], [[:name, :node], [:type, :node], [:ivar_name, :attr_ivar_name], [:kind, [:enum, [:instance, :singleton]]], [:annotations, :node_list], [:comment, :node], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::ClassInstanceVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::ClassVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Extend", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Include", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::InstanceVariable", true, [[:name, true], [:colon, true], [:kind, false]], [[:name, :node], [:type, :node], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::MethodDefinition", true, [[:keyword, true], [:name, true], [:kind, false], [:overloading, false], [:visibility, false]], [[:name, :node], [:kind, [:enum, [:instance, :singleton, :singleton_instance]]], [:overloads, :node_list], [:annotations, :node_list], [:comment, :node], [:overloading, :bool], [:visibility, [:enum, [nil, :public, :private]]]], false],
+        [:node, "RBS::AST::Members::MethodDefinition::Overload", false, nil, [[:annotations, :node_list], [:method_type, :node]], false],
+        [:node, "RBS::AST::Members::Prepend", true, [[:name, true], [:keyword, true], [:args, false]], [[:name, :node], [:args, :node_list], [:annotations, :node_list], [:comment, :node]], false],
+        [:node, "RBS::AST::Members::Private", true, nil, nil, false],
+        [:node, "RBS::AST::Members::Public", true, nil, nil, false],
+        [:node, "RBS::AST::Ruby::Annotations::BlockParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:ampersand_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:question_location, :location_range], [:type_location, :location_range], [:type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ClassAliasAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:type_name, :node], [:type_name_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ColonMethodTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:annotations, :node_list], [:method_type, :node]], false],
+        [:node, "RBS::AST::Ruby::Annotations::DoubleSplatParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:star2_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::InstanceVariableAnnotation", true, nil, [[:prefix_location, :location_range], [:ivar_name, :node], [:ivar_name_location, :location_range], [:colon_location, :location_range], [:type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::MethodTypesAnnotation", true, nil, [[:prefix_location, :location_range], [:overloads, :node_list], [:vertical_bar_locations, :location_range_list], [:dot3_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ModuleAliasAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:type_name, :node], [:type_name_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ModuleSelfAnnotation", true, nil, [[:prefix_location, :location_range], [:keyword_location, :location_range], [:colon_location, :location_range], [:name, :node], [:args, :node_list], [:open_bracket_location, :location_range], [:close_bracket_location, :location_range], [:args_comma_locations, :location_range_list], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::NodeTypeAssertion", true, nil, [[:prefix_location, :location_range], [:type, :node]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::ReturnTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:return_location, :location_range], [:colon_location, :location_range], [:return_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::SkipAnnotation", true, nil, [[:prefix_location, :location_range], [:skip_location, :location_range], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::SplatParamTypeAnnotation", true, nil, [[:prefix_location, :location_range], [:star_location, :location_range], [:name_location, :location_range], [:colon_location, :location_range], [:param_type, :node], [:comment_location, :location_range]], false],
+        [:node, "RBS::AST::Ruby::Annotations::TypeApplicationAnnotation", true, nil, [[:prefix_location, :location_range], [:type_args, :node_list], [:close_bracket_location, :location_range], [:comma_locations, :location_range_list]], false],
+        [:string_value],
+        [:node, "RBS::AST::TypeParam", true, [[:name, true], [:variance, false], [:unchecked, false], [:upper_bound, false], [:lower_bound, false], [:default, false]], [[:name, :node], [:variance, [:enum, [:invariant, :covariant, :contravariant]]], [:upper_bound, :node], [:lower_bound, :node], [:default_type, :node], [:unchecked, :bool]], false],
+        [:node, "RBS::MethodType", true, [[:type, true], [:type_params, false]], [[:type_params, :node_list], [:type, :node], [:block, :node]], true],
+        [:namespace],
+        [:signature],
+        [:type_name],
+        [:node, "RBS::Types::Alias", true, [[:name, true], [:args, false]], [[:name, :node], [:args, :node_list]], false],
+        [:node, "RBS::Types::Bases::Any", true, nil, [[:todo, :bool]], false],
+        [:node, "RBS::Types::Bases::Bool", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Bottom", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Class", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Instance", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Nil", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Self", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Top", true, nil, nil, false],
+        [:node, "RBS::Types::Bases::Void", true, nil, nil, false],
+        [: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::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],
+        [:node, "RBS::Types::Literal", true, nil, [[:literal, :node]], false],
+        [:node, "RBS::Types::Optional", true, nil, [[:type, :node]], false],
+        [:node, "RBS::Types::Proc", true, nil, [[:type, :node], [:block, :node], [:self_type, :node]], false],
+        [:node, "RBS::Types::Record", true, nil, [[:all_fields, :hash]], false],
+        [:record_field],
+        [:node, "RBS::Types::Tuple", true, nil, [[:types, :node_list]], false],
+        [:node, "RBS::Types::Union", true, nil, [[:types, :node_list]], false],
+        [:node, "RBS::Types::UntypedFunction", false, nil, [[:return_type, :node]], false],
+        [:node, "RBS::Types::Variable", true, nil, [[:name, :node]], false],
+      ].freeze
+    end
+  end
+end

data/lib/rbs.rb

@@ -4,7 +4,11 @@ require "rbs/version"
 
 require "set"
 require "json"
-require "pathname" unless defined?(Pathname)
+# Always require pathname: `Pathname()` (Kernel#Pathname) is only defined once
+# pathname is loaded. Guarding on `defined?(Pathname)` is wrong because another
+# library (e.g. Bundler) can define the Pathname constant without that method,
+# which left RBS::EnvironmentLoader's `Pathname(...)` undefined on JRuby.
+require "pathname"
 require "pp"
 require "logger"
 require "tsort"
@@ -51,6 +55,7 @@ require "rbs/resolver/constant_resolver"
 require "rbs/resolver/type_name_resolver"
 require "rbs/ast/comment"
 require "rbs/writer"
+require "rbs/rewriter"
 require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
@@ -68,7 +73,14 @@ require "rbs/type_alias_dependency"
 require "rbs/type_alias_regularity"
 require "rbs/collection"
 
-require "rbs_extension"
+if RUBY_ENGINE == "jruby"
+  # JRuby cannot load the MRI C extension. Run the parser in WebAssembly and
+  # provide pure-Ruby implementations of RBS::Location and RBS::Parser instead.
+  require "rbs/wasm/location"
+  require "rbs/wasm/parser"
+else
+  require "rbs_extension"
+end
 require "rbs/parser_aux"
 require "rbs/location_aux"
 

data/lib/rbs_jars.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# This is the file jar-dependencies generates from the `jar` requirements in
+# rbs.gemspec, kept with hand edits:
+#   1. the `com.dylibso.chicory:runtime` require_jar line is corrected -- the
+#      generator mangles that artifact id to `jar` (it collides with a Maven
+#      scope keyword), which breaks loading;
+#   2. the "# this is a generated file" marker is dropped so jar-dependencies
+#      does not regenerate (and re-break) this file at gem install;
+#   3. a frozen_string_literal magic comment is added (rubocop).
+# `rake wasm:install_jars` downloads the jars into ~/.m2; to refresh the list
+# after a version bump, regenerate the file and re-apply these edits.
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'com/dylibso/chicory/compiler/1.7.5/compiler-1.7.5.jar'
+  require 'com/dylibso/chicory/runtime/1.7.5/runtime-1.7.5.jar'
+  require 'com/dylibso/chicory/wasm/1.7.5/wasm-1.7.5.jar'
+  require 'org/ow2/asm/asm/9.9.1/asm-9.9.1.jar'
+  require 'org/ow2/asm/asm-commons/9.9.1/asm-commons-9.9.1.jar'
+  require 'org/ow2/asm/asm-tree/9.9.1/asm-tree-9.9.1.jar'
+  require 'org/ow2/asm/asm-util/9.9.1/asm-util-9.9.1.jar'
+  require 'org/ow2/asm/asm-analysis/9.9.1/asm-analysis-9.9.1.jar'
+  require 'com/dylibso/chicory/wasi/1.7.5/wasi-1.7.5.jar'
+  require 'com/dylibso/chicory/log/1.7.5/log-1.7.5.jar'
+end
+
+if defined? Jars
+  require_jar 'com.dylibso.chicory', 'compiler', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'runtime', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'wasm', '1.7.5'
+  require_jar 'org.ow2.asm', 'asm', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-commons', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-tree', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-util', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-analysis', '9.9.1'
+  require_jar 'com.dylibso.chicory', 'wasi', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'log', '1.7.5'
+end

data/lib/rdoc_plugin/parser.rb

@@ -14,6 +14,11 @@ module RBS
       end
 
       def scan
+        Kernel.warn(
+          "The RBS RDoc parser plugin is deprecated and will be removed from RBS. " \
+          "RDoc 8.0 provides RBS parsing directly."
+        )
+
         _, _, decls = ::RBS::Parser.parse_signature(@content)
         decls.each do |decl|
           parse_member(decl: decl, context: @top_level)

data/rbs.gemspec

@@ -30,12 +30,42 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       [
-        %r{^(test|spec|features|bin|steep|benchmark|templates|rust)/},
+        %r{^(test|spec|features|bin|steep|benchmark|templates|rust|\.vscode)/},
         /Gemfile/,
       ].any? {|r| f.match(r) }
     end
   end
-  spec.extensions = %w{ext/rbs_extension/extconf.rb}
+
+  # JRuby cannot load the MRI C extension. On JRuby (and in the `java` platform
+  # gem, built with RBS_PLATFORM=java) RBS runs the WebAssembly-backed parser, so
+  # ship the prebuilt parser (built by `rake wasm:build`) and skip the C
+  # extension. The Chicory/ASM jars the runtime needs are NOT shipped in the gem:
+  # they are declared as `jar-dependencies` requirements below and fetched from
+  # Maven Central at install time (see lib/rbs/wasm/jars.rb).
+  building_java_gem = ENV["RBS_PLATFORM"] == "java"
+  on_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+  if building_java_gem || on_jruby
+    # Only stamp the platform when building the release gem; leave it unset for
+    # local development on JRuby so it still matches a `ruby` platform lockfile.
+    spec.platform = "java" if building_java_gem
+    # rbs_parser.wasm is a build artifact (not tracked in git), so add it
+    # explicitly. lib/rbs_jars.rb is committed, so git ls-files already has it.
+    spec.files += Dir.chdir(File.expand_path('..', __FILE__)) do
+      Dir.glob("lib/rbs/wasm/rbs_parser.wasm")
+    end
+
+    # jar-dependencies (bundled with JRuby) downloads these jars from Maven when
+    # the gem is installed, keeping the gem small and avoiding conflicting copies.
+    # Only the top-level artifacts are declared; Maven resolves the rest (runtime,
+    # wasm, asm, ...) transitively. lib/rbs_jars.rb require_jars the full resolved
+    # set at load time.
+    spec.add_dependency "jar-dependencies", ">= 0.1.7"
+    spec.requirements << "jar com.dylibso.chicory:compiler, 1.7.5"
+    spec.requirements << "jar com.dylibso.chicory:wasi, 1.7.5"
+  else
+    spec.extensions = %w{ext/rbs_extension/extconf.rb}
+  end
 
   if false
     spec.required_ruby_version = ">= 3.4"

data/sig/annotate/rdoc_annotater.rbs

@@ -8,9 +8,10 @@ module RBS
 
       def initialize: (source: RDocSource) -> void
 
-      def annotate_file: (Pathname, preserve: bool) -> void
+      def annotate_file: (Pathname) -> void
+                       | %a{deprecated: it preserves the format by default} (Pathname, preserve: bool) -> void
 
-      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+      def annotate_decls: (Array[AST::Declarations::t], Rewriter, ?outer: Array[Namespace]) -> void
 
       interface _PathTester
         def test_path: (String) -> bool
@@ -50,15 +51,15 @@ module RBS
 
       def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
 
-      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+      def annotate_constant: (AST::Declarations::Constant, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+      def annotate_method: (TypeName, AST::Members::MethodDefinition, Rewriter) -> void
 
-      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+      def annotate_alias: (TypeName, AST::Members::Alias, Rewriter) -> void
 
-      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor, Rewriter) -> void
 
       def annotations: (_Annotated) -> Annotations
 
@@ -70,10 +71,12 @@ module RBS
       # - If empty string is given as `comment`, it deletes the original comment.
       # - If `nil` is given as `comment`, it keeps the original comment.
       #
-      def replace_comment: (Object & _Commented, String? comment) -> void
+      def replace_comment: (_Commented, String?, Rewriter) -> void
 
       interface _Commented
-        def comment: () -> AST::Comment?
+        %a{pure} def comment: () -> AST::Comment?
+        %a{pure} def location: () -> Location[untyped, untyped]?
+        def annotations: () -> Array[AST::Annotation]
       end
 
       def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName