rbs 4.0.3 → 4.1.0.pre.2

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/rbs.gemspec

@@ -30,12 +30,29 @@ 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 and the Chicory jars (assembled by
+  # `rake wasm:jruby_setup`) and skip the C extension.
+  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
+    spec.files += Dir.chdir(File.expand_path('..', __FILE__)) do
+      Dir.glob("lib/rbs/wasm/rbs_parser.wasm") + Dir.glob("lib/rbs/wasm/jars/*.jar")
+    end
+  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

data/sig/ast/ruby/annotations.rbs

@@ -7,6 +7,7 @@ module RBS
                                 | SkipAnnotation
                                 | ReturnTypeAnnotation
                                 | InstanceVariableAnnotation
+                                | ModuleSelfAnnotation
                                 | ParamTypeAnnotation
                                 | SplatParamTypeAnnotation
                                 | DoubleSplatParamTypeAnnotation
@@ -237,6 +238,54 @@ module RBS
           def type_fingerprint: () -> untyped
         end
 
+        # `@rbs module-self: NAME[ARGS] -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs module-self: _Each[String, Integer] -- comment
+        # ^^^^                                                -- prefix_location
+        #      ^^^^^^^^^^^                                    -- keyword_location
+        #                 ^                                   -- colon_location
+        #                        ^                            -- open_bracket_location
+        #                               ^                     -- args_comma_locations[0]
+        #                                        ^            -- close_bracket_location
+        #                                          ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        class ModuleSelfAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader name: TypeName
+
+          attr_reader args: Array[Types::t]
+
+          attr_reader open_bracket_location: Location?
+
+          attr_reader close_bracket_location: Location?
+
+          attr_reader args_comma_locations: Array[Location]
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            keyword_location: Location,
+            colon_location: Location,
+            name: TypeName,
+            args: Array[Types::t],
+            open_bracket_location: Location?,
+            close_bracket_location: Location?,
+            args_comma_locations: Array[Location],
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
         class ParamTypeAnnotation < Base
           attr_reader name_location: Location
 

data/sig/ast/ruby/members.rbs

@@ -16,6 +16,7 @@ module RBS
                | IncludeMember | ExtendMember | PrependMember
                | AttrReaderMember | AttrWriterMember | AttrAccessorMember
                | InstanceVariableMember
+               | ModuleSelfMember
 
         class MethodTypeAnnotation
           class DocStyle
@@ -83,10 +84,15 @@ module RBS
 
           attr_reader name: Symbol
           attr_reader node: Prism::DefNode
+          attr_reader kind: :instance | :singleton
           attr_reader method_type: MethodTypeAnnotation
           attr_reader leading_comment: CommentBlock?
 
-          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation, CommentBlock? leading_comment) -> void
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation, CommentBlock? leading_comment, ?kind: :instance | :singleton) -> void
+
+          def singleton?: () -> bool
+
+          def instance?: () -> bool
 
           def location: () -> Location
 
@@ -172,6 +178,20 @@ module RBS
 
           def type_fingerprint: () -> untyped
         end
+
+        class ModuleSelfMember < Base
+          attr_reader annotation: Annotations::ModuleSelfAnnotation
+
+          def initialize: (Buffer, Annotations::ModuleSelfAnnotation) -> void
+
+          def name: () -> TypeName
+
+          def args: () -> Array[Types::t]
+
+          def location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
       end
     end
   end

data/sig/buffer.rbs

@@ -60,6 +60,19 @@ module RBS
     def rbs_location: (Prism::Location) -> Location
                     | (Prism::Location, Prism::Location) -> Location
 
+    # Translate a byte offset (into the top buffer's source) to a character offset.
+    #
+    # Resolution is delegated to the top buffer, which keeps a sparse cache of
+    # resolved (byte, char) pairs so successive calls scan only the delta from the
+    # nearest cached pair. Amortizes to O(content_size) across all calls; a single
+    # call is one byteslice + length.
+    #
+    def character_offset: (Integer byte_offset) -> Integer
+
+    # Sparse cache backing `#character_offset`: a pair `[byte_keys, char_values]`
+    # kept in ascending byte order to support binary search.
+    @character_offset_cache: [Array[Integer], Array[Integer]]?
+
     # Construct a buffer from substrings of this buffer.
     #
     # The returned buffer contains lines from given ranges.
@@ -75,7 +88,12 @@ module RBS
     # buffer.sub_buffer(lines: [5..7])          # => Raises an error because the range contains newline
     # ```
     #
-    %a{pure} def sub_buffer: (lines: Array[Range[Integer]]) -> Buffer
+    # `byte_lines_hint:` is an optional performance hint: byte ranges corresponding
+    # to `lines:`. When provided, slicing uses `byteslice` (O(slice_size) per line)
+    # instead of `content[char_range]`, which on a multi-byte string is O(content_size)
+    # per call. Result is identical either way.
+    #
+    %a{pure} def sub_buffer: (lines: Array[Range[Integer]], ?byte_lines_hint: Array[Range[Integer]]?) -> Buffer
 
     %a{pure} def parent_buffer: () -> Buffer?
 

data/sig/collection/config/lockfile_generator.rbs

@@ -6,6 +6,8 @@ module RBS
         #
         ALUMNI_STDLIBS: Hash[String, String?]
 
+        NONGEM_STDLIBS: Set[String]
+
         class GemfileLockMismatchError < StandardError
           @expected: Pathname
 

data/sig/inline_parser.rbs

@@ -110,6 +110,8 @@ module RBS
 
       def report_unused_block: (AST::Ruby::CommentBlock) -> void
 
+      def visit_class_or_module_body: (module_context, Prism::ClassNode | Prism::ModuleNode) -> void
+
       private
 
       def parse_mixin_call: (Prism::CallNode) -> void

data/sig/manifest.yaml

@@ -1,5 +1,4 @@
 dependencies:
-  - name: logger
   - name: json
   - name: optparse
   - name: tsort

data/sig/namespace.rbs

@@ -40,10 +40,30 @@ module RBS
 
     @parent: Namespace?
 
+    @hash: Integer?
+
     self.@root: Namespace?
 
     self.@empty: Namespace?
 
+    self.@intern_mutex: Mutex
+
+    # Per-`absolute` flag tries of nested Hashes keyed on path Symbols,
+    # with the cached Namespace stored under the `INTERN_LEAF` sentinel
+    # at each path's terminal node.
+    self.@intern_trie_absolute: Hash[Symbol | Module, untyped]
+
+    self.@intern_trie_relative: Hash[Symbol | Module, untyped]
+
+    INTERN_LEAF: Module
+
+    # Returns an interned `Namespace` instance.
+    #
+    # Subsequent calls with structurally equal `path` and `absolute` arguments
+    # return the same object. The internal `path` array is duplicated and
+    # frozen before being cached.
+    def self.[]: (Array[Symbol] path, boolish absolute) -> Namespace
+
     # Returns new _empty_ namespace.
     def self.empty: () -> Namespace
 

data/sig/parser.rbs

@@ -140,6 +140,16 @@ module RBS
 
     def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [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
+    # docs/wasm_serialization.md). The `_to_bytes` variants exist so the
+    # 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_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos) -> String
+
     def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
 
     def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]

data/sig/resolver/type_name_resolver.rbs

@@ -6,8 +6,6 @@ module RBS
     # It just ignores included modules and super classes.
     #
     class TypeNameResolver
-      type query = [TypeName, context]
-
       def initialize: (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> void
 
       def self.build: (Environment) -> instance
@@ -32,7 +30,7 @@ module RBS
 
       attr_reader aliases: Hash[TypeName, [TypeName, context]]
 
-      attr_reader cache: Hash[query, TypeName?]
+      attr_reader cache: Hash[context, Hash[TypeName, TypeName?]]
 
       # Returns the type name if it exists in `all_names` (normalized)
       #
@@ -42,7 +40,7 @@ module RBS
       #
       def aliased_name?: (TypeName) -> TypeName?
 
-      def try_cache: (query) { () -> TypeName? } -> TypeName?
+      def try_cache: (TypeName, context) { () -> TypeName? } -> TypeName?
 
       # Translates the head module name in the context and returns an absolute type name
       #

data/sig/rewriter.rbs

@@ -0,0 +1,45 @@
+module RBS
+  # Rewriter performs targeted character-range replacements on Buffer content.
+  #
+  # Unlike Writer which regenerates entire source from AST, Rewriter preserves
+  # everything outside the rewritten ranges, including non-documentation comments.
+  #
+  # Rewrite requests are buffered and applied all at once when `#string` is called.
+  #
+  class Rewriter
+    attr_reader buffer: Buffer
+
+    # Initialize with a toplevel buffer.
+    # Raises if the buffer has a parent (non-toplevel).
+    #
+    def initialize: (Buffer buffer) -> void
+
+    # Register a rewrite request for the given location.
+    #
+    def rewrite: (Location[untyped, untyped] location, String string) -> self
+
+    # Add a new comment before the earliest of the given locations.
+    #
+    def add_comment: (*Location[untyped, untyped] locations, content: String) -> self
+
+    # Replace an existing comment's content.
+    #
+    def replace_comment: (AST::Comment comment, content: String) -> self
+
+    # Delete an existing comment.
+    #
+    def delete_comment: (AST::Comment comment) -> self
+
+    # Apply all buffered rewrites and return the resulting string.
+    #
+    # Raises if any rewrite ranges overlap.
+    #
+    def string: () -> String
+
+    private
+
+    def format_comment: (String content, String indent) -> String
+
+    @rewrites: Array[[Location[untyped, untyped], String]]
+  end
+end

data/sig/typename.rbs

@@ -28,6 +28,21 @@ module RBS
     #
     def initialize: (namespace: Namespace, name: Symbol) -> void
 
+    @hash: Integer?
+
+    self.@intern_mutex: Mutex
+
+    # Two-level Hash keyed by canonical Namespace identity (outer uses
+    # `compare_by_identity`) and name Symbol.
+    self.@intern_cache: Hash[Namespace, Hash[Symbol, TypeName]]
+
+    # Returns an interned `TypeName` instance.
+    #
+    # The given `namespace` is canonicalized so cached instances always hold an
+    # interned namespace. Subsequent calls with structurally equal arguments
+    # return the same object.
+    def self.[]: (Namespace namespace, Symbol name) -> TypeName
+
     def ==: (untyped other) -> bool
 
     def hash: () -> Integer

data/sig/unit_test/type_assertions.rbs

@@ -179,6 +179,10 @@ module RBS
       #
       def assert_type: (String | Types::t value_type, untyped value) -> void
 
+      # Asserts if RBS definition declares given `method_name` with `visibility`
+      #
+      def assert_visibility: (:private | :public visibility, Symbol method_name) -> void
+
       # Allow non _simple-type_ method types given to `assert_send_type` and `refute_send_type`
       #
       # ```ruby

data/sig/wasm/deserializer.rbs

@@ -0,0 +1,66 @@
+module RBS
+  module WASM
+    # Rebuilds RBS::AST objects from the binary buffer produced by
+    # `rbs_serialize_node` (src/serialize.c), driven by SerializationSchema.
+    class Deserializer
+      @bytes: String
+
+      @buffer: Buffer
+
+      @encoding: Encoding
+
+      @pos: Integer
+
+      @class_cache: Hash[String, untyped]
+
+      # Deserialize a buffer produced for a whole signature, returning
+      # `[directives, declarations]` to match RBS::Parser._parse_signature.
+      def self.deserialize: (String bytes, Buffer buffer) -> untyped
+
+      # Deserialize a bare node list (RBS::Parser._parse_type_params).
+      def self.deserialize_node_list: (String bytes, Buffer buffer) -> Array[untyped]
+
+      # Deserialize the token stream from rbs_wasm_lex (RBS::Parser._lex).
+      def self.deserialize_tokens: (String bytes, Buffer buffer) -> Array[[ Symbol, Location ]]
+
+      def initialize: (String bytes, Buffer buffer) -> void
+
+      # Reads the next node and returns the reconstructed Ruby value.
+      def read_node: () -> untyped
+
+      def read_node_list: () -> Array[untyped]
+
+      def read_tokens: () -> Array[[ Symbol, Location ]]
+
+      private
+
+      def read_struct: (Array[untyped] entry) -> untyped
+
+      def read_field: (untyped reader) -> untyped
+
+      def read_hash: () -> Hash[untyped, untyped]
+
+      def read_count: () -> Integer
+
+      def read_location: (Array[untyped]? loc_children) -> Location?
+
+      def read_location_value: () -> Location?
+
+      def read_location_value_list: () -> Array[Location?]
+
+      def read_attr_ivar_name: () -> (Symbol | false | nil)
+
+      def read_range: () -> [ Integer, Integer ]?
+
+      def read_u8: () -> Integer
+
+      def read_u32: () -> Integer
+
+      def read_i32: () -> Integer
+
+      def read_string: (Encoding encoding) -> String
+
+      def class_for: (String name) -> untyped
+    end
+  end
+end

data/sig/wasm/serialization_schema.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module WASM
+    # Generated from config.yml. See `templates/lib/rbs/wasm/serialization_schema.rb.erb`.
+    module SerializationSchema
+      # The node tag used for interned symbols (`rbs_ast_symbol`).
+      SYMBOL_TAG: Integer
+
+      # Indexed by node tag. Each entry describes how to decode one node; see the
+      # generated file for the exact shape.
+      SCHEMA: Array[Array[untyped]?]
+    end
+  end
+end