rbs 4.0.3 → 4.1.3

data/lib/rbs/resolver/type_name_resolver.rb

@@ -29,11 +29,9 @@ module RBS
         new(all_names, aliases)
       end
 
-      def try_cache(query)
-        cache.fetch(query) do
-          result = yield
-          cache[query] = result
-        end
+      def try_cache(type_name, context)
+        inner = cache[context] ||= {}
+        inner.fetch(type_name) { inner[type_name] = yield }
       end
 
       def resolve(type_name, context:)
@@ -41,7 +39,7 @@ module RBS
           return type_name
         end
 
-        try_cache([type_name, context]) do
+        try_cache(type_name, context) do
           if type_name.class?
             resolve_namespace0(type_name, context, Set.new) || nil
           else
@@ -51,7 +49,7 @@ module RBS
               resolve_type_name(type_name.name, context)
             else
               if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
-                type_name = TypeName.new(name: type_name.name, namespace: namespace.to_namespace)
+                type_name = TypeName[namespace.to_namespace, type_name.name]
                 has_type_name?(type_name)
               end
             end
@@ -68,7 +66,7 @@ module RBS
           raise "Type name must be a class name: #{type_name}"
         end
 
-        try_cache([type_name, context]) do
+        try_cache(type_name, context) do
           ns = resolve_namespace0(type_name, context, Set.new) or return ns
         end
       end
@@ -93,10 +91,10 @@ module RBS
             resolve_type_name(type_name, outer)
           else
             has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            has_type_name?(TypeName.new(name: type_name, namespace: inner.to_namespace)) || resolve_type_name(type_name, outer)
+            has_type_name?(TypeName[inner.to_namespace, type_name]) || resolve_type_name(type_name, outer)
           end
         else
-          type_name = TypeName.new(name: type_name, namespace: Namespace.root)
+          type_name = TypeName[Namespace.root, type_name]
           has_type_name?(type_name)
         end
       end
@@ -109,11 +107,11 @@ module RBS
             resolve_head_namespace(head, outer)
           when TypeName
             has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            type_name = TypeName.new(name: head, namespace: inner.to_namespace)
+            type_name = TypeName[inner.to_namespace, head]
             has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
           end
         else
-          type_name = TypeName.new(name: head, namespace: Namespace.root)
+          type_name = TypeName[Namespace.root, head]
           has_type_name?(type_name) || aliased_name?(type_name)
         end
       end
@@ -140,7 +138,7 @@ module RBS
 
         head =
           if type_name.absolute?
-            root_name = TypeName.new(name: head, namespace: Namespace.root)
+            root_name = TypeName[Namespace.root, head]
             has_type_name?(root_name) || aliased_name?(root_name)
           else
             resolve_head_namespace(head, context)
@@ -152,7 +150,7 @@ module RBS
           end
 
           tail.inject(head) do |namespace, name|
-            type_name = TypeName.new(name: name, namespace: namespace.to_namespace)
+            type_name = TypeName[namespace.to_namespace, name]
             case
             when has_type_name?(type_name)
               type_name

data/lib/rbs/rewriter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RBS
+  class Rewriter
+    attr_reader :buffer
+
+    def initialize(buffer)
+      raise "Rewriter only supports toplevel buffers" if buffer.parent
+
+      @buffer = buffer
+      @rewrites = []
+    end
+
+    def rewrite(location, string)
+      @rewrites.each do |existing_location, _|
+        if location.start_pos < existing_location.end_pos && existing_location.start_pos < location.end_pos
+          raise "Overlapping rewrites: #{existing_location} and #{location}"
+        end
+      end
+
+      @rewrites << [location, string]
+      self
+    end
+
+    def add_comment(*locations, content:)
+      earliest = locations.min_by(&:start_pos) or raise "At least one location is required"
+      insert_pos = earliest.start_pos
+      indent = " " * earliest.start_column
+
+      formatted = format_comment(content, indent)
+
+      loc = Location.new(buffer, insert_pos, insert_pos)
+      rewrite(loc, "#{formatted}\n#{indent}")
+    end
+
+    def replace_comment(comment, content:)
+      location = comment.location or raise "Comment must have a location"
+      indent = " " * location.start_column
+
+      rewrite(location, format_comment(content, indent))
+    end
+
+    def delete_comment(comment)
+      location = comment.location or raise "Comment must have a location"
+      line_start = location.start_pos - location.start_column
+      line_end = location.end_pos + 1
+      loc = Location.new(buffer, line_start, line_end)
+      rewrite(loc, "")
+    end
+
+    def string
+      result = buffer.content.dup
+
+      @rewrites.sort_by { |location, _| location.start_pos }.reverse_each do |location, replacement|
+        result[location.start_pos...location.end_pos] = replacement
+      end
+
+      result
+    end
+
+    private
+
+    def format_comment(content, indent)
+      content.lines.map do |line|
+        line = line.chomp
+        line.empty? ? "#" : "# #{line}"
+      end.join("\n#{indent}")
+    end
+  end
+end

data/lib/rbs/test/type_check.rb

@@ -356,7 +356,12 @@ module RBS
         when Types::Variable
           true
         when Types::Literal
-          type.literal == val
+          begin
+            type.literal == val
+          rescue NoMethodError
+            raise if defined?(val.==)
+            false
+          end
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection

data/lib/rbs/type_name.rb

@@ -22,14 +22,40 @@ module RBS
               end
     end
 
+    # Process-wide flyweight cache. Two-level Hash keyed by canonical
+    # Namespace identity (outer uses `compare_by_identity`) and name
+    # Symbol.
+    @intern_mutex = Mutex.new
+    @intern_cache = {}  #: Hash[Namespace, Hash[Symbol, TypeName]]
+    @intern_cache.compare_by_identity
+
+    # Returns a canonical `TypeName` instance for the given `namespace` /
+    # `name` pair. The namespace is canonicalized through `Namespace.[]`
+    # so identity-based lookup works regardless of the caller passing a
+    # fresh `Namespace.new` or an already-interned instance.
+    def self.[](namespace, name)
+      ns = Namespace[namespace.path, namespace.absolute?]
+
+      inner = @intern_cache[ns]
+      if inner && (cached = inner[name])
+        return cached
+      end
+
+      @intern_mutex.synchronize do
+        inner = (@intern_cache[ns] ||= {})
+        inner[name] ||= new(namespace: ns, name: name)
+      end
+    end
+
     def ==(other)
+      return true if equal?(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
 
     alias eql? ==
 
     def hash
-      namespace.hash ^ name.hash
+      @hash ||= namespace.hash ^ name.hash
     end
 
     def to_s
@@ -53,7 +79,7 @@ module RBS
     end
 
     def absolute!
-      self.class.new(namespace: namespace.absolute!, name: name)
+      TypeName[namespace.absolute!, name]
     end
 
     def absolute?
@@ -61,7 +87,7 @@ module RBS
     end
 
     def relative!
-      self.class.new(namespace: namespace.relative!, name: name)
+      TypeName[namespace.relative!, name]
     end
 
     def interface?
@@ -69,7 +95,7 @@ module RBS
     end
 
     def with_prefix(namespace)
-      self.class.new(namespace: namespace + self.namespace, name: name)
+      TypeName[namespace + self.namespace, name]
     end
 
     def split
@@ -80,23 +106,17 @@ module RBS
       if other.absolute?
         other
       else
-        TypeName.new(
-          namespace: self.to_namespace + other.namespace,
-          name: other.name
-        )
+        TypeName[self.to_namespace + other.namespace, other.name]
       end
     end
-    
+
     def self.parse(string)
       absolute = string.start_with?("::")
 
       *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
       raise unless name
 
-      TypeName.new(
-        name: name,
-        namespace: RBS::Namespace.new(path: path, absolute: absolute)
-      )
+      TypeName[Namespace[path, absolute], name]
     end
   end
 end

data/lib/rbs/unit_test/type_assertions.rb

@@ -180,11 +180,11 @@ module RBS
           )
           errors = typecheck.method_call(method, method_type, trace, errors: [])
 
-          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, -> { "Call trace does not match with given method type: #{trace.inspect}" }
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.any? {|es| es.empty? }, -> { "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           raise exception if exception
 
@@ -204,11 +204,11 @@ module RBS
           )
           errors = typecheck.method_call(method, method_type, trace, errors: [])
 
-          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, -> { "Call trace does not match with given method type: #{trace.inspect}" }
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.any? {|es| es.empty? }, -> { "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           # Use `instnace_of?` instead of `is_a?` as we want to check for _the exact exception class_.
           assert exception.instance_of? error_type
@@ -246,7 +246,7 @@ module RBS
 
           method_defs = method_defs(method)
           all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
-          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
+          assert all_errors.all? {|es| es.size > 0 }, -> { "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}" }
 
           result
         end
@@ -323,6 +323,15 @@ module RBS
         assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
       end
 
+      def assert_visibility(visibility, method)
+        _, definition = target
+        method_entry = definition.methods[method]
+
+        assert method_entry, "Method `#{method}` not found in RBS definition"
+        assert visibility == method_entry.accessibility,
+          "Expected `#{method}` to be #{visibility}, but was #{method_entry.accessibility}"
+      end
+
       def assert_type(type, value)
         typecheck = RBS::Test::TypeCheck.new(
           self_class: value.class,

data/lib/rbs/version.rb

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

data/lib/rbs/wasm/deserializer.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative "serialization_schema"
+
+module RBS
+  module WASM
+    # Rebuilds RBS::AST objects from the binary buffer produced by
+    # `rbs_serialize_node` (src/serialize.c), driven by the generated
+    # SerializationSchema. This is the pure-Ruby counterpart of the C extension's
+    # ast_translation.c, used when the parser runs inside WebAssembly (JRuby).
+    #
+    # All locations are reconstructed through the public RBS::Location API, so the
+    # same code works whether RBS::Location is backed by the C extension (CRuby)
+    # or by a pure-Ruby implementation (JRuby).
+    class Deserializer
+      # Deserialize a buffer produced for a whole signature, returning
+      # `[directives, declarations]` to match RBS::Parser._parse_signature.
+      def self.deserialize(bytes, buffer)
+        new(bytes, buffer).read_node
+      end
+
+      # Deserialize a bare node list (rbs_serialize_node_list), e.g. the result
+      # of RBS::Parser._parse_type_params.
+      def self.deserialize_node_list(bytes, buffer)
+        new(bytes, buffer).read_node_list
+      end
+
+      # Deserialize the token stream produced by rbs_wasm_lex into the
+      # [type, location] pairs RBS::Parser._lex returns.
+      def self.deserialize_tokens(bytes, buffer)
+        new(bytes, buffer).read_tokens
+      end
+
+      def initialize(bytes, buffer)
+        @bytes = bytes
+        @buffer = buffer
+        # Symbols and rbs_string fields (comments, annotations) inherit the
+        # source encoding, matching ast_translation.c. String/Integer literal
+        # nodes are always UTF-8 (see read_node).
+        @encoding = buffer.content.encoding
+        @pos = 0
+        @class_cache = {} #: Hash[String, untyped]
+      end
+
+      def read_node
+        tag = read_u8
+        return nil if tag == 0
+        return read_string(@encoding).to_sym if tag == SerializationSchema::SYMBOL_TAG
+
+        entry = SerializationSchema::SCHEMA[tag] or raise "Unknown node tag: #{tag}"
+
+        case entry[0]
+        when :node then read_struct(entry)
+        when :bool then read_u8 != 0
+        when :integer then read_string(Encoding::UTF_8).to_i
+        when :string_value then read_string(Encoding::UTF_8)
+        when :record_field then [read_node, read_u8 != 0]
+        when :signature then [read_node_list, read_node_list]
+        when :namespace then RBS::Namespace[read_node_list, read_u8 != 0]
+        when :type_name then RBS::TypeName[read_node, read_node]
+        else raise "Unknown schema entry kind: #{entry[0].inspect}"
+        end
+      end
+
+      def read_node_list
+        Array.new(read_count) { read_node }
+      end
+
+      # The lex stream has no leading count: read records until the buffer is
+      # exhausted. Each is a token type name followed by its character range.
+      def read_tokens
+        tokens = [] #: Array[[ Symbol, Location ]]
+        until @pos >= @bytes.bytesize
+          type = read_string(Encoding::UTF_8).to_sym
+          start_char = read_i32
+          end_char = read_i32
+          tokens << [type, RBS::Location.new(@buffer, start_char, end_char)]
+        end
+        tokens
+      end
+
+      private
+
+      def read_struct(entry)
+        _, class_name, expose_location, loc_children, fields, resolve_type_params = entry
+
+        location = read_location(loc_children) if expose_location
+
+        kwargs = {} #: Hash[Symbol, untyped]
+        (fields || []).each do |name, reader|
+          kwargs[name] = read_field(reader)
+        end
+
+        RBS::AST::TypeParam.resolve_variables(kwargs[:type_params]) if resolve_type_params
+
+        klass = class_for(class_name)
+        if expose_location
+          klass.new(location: location, **kwargs)
+        else
+          klass.new(**kwargs)
+        end
+      end
+
+      def read_field(reader)
+        case reader
+        when :node then read_node
+        when :node_list then read_node_list
+        when :hash then read_hash
+        when :string then read_string(@encoding)
+        when :bool then read_u8 != 0
+        when :location_range then read_location_value
+        when :location_range_list then read_location_value_list
+        when :attr_ivar_name then read_attr_ivar_name
+        else # [:enum, [value_or_nil, ...]]
+          reader[1][read_u8]
+        end
+      end
+
+      def read_hash
+        hash = {} #: Hash[untyped, untyped]
+        read_count.times do
+          key = read_node
+          hash[key] = read_node
+        end
+        hash
+      end
+
+      # A count of nested items. Each item is at least one byte, so a count that
+      # exceeds the bytes remaining signals the cursor has drifted out of sync.
+      def read_count
+        count = read_u32
+        if count > @bytes.bytesize - @pos
+          raise "Corrupt buffer: count #{count} exceeds #{@bytes.bytesize - @pos} remaining bytes at offset #{@pos}"
+        end
+        count
+      end
+
+      # The base location of a node, followed by its named child ranges.
+      def read_location(loc_children)
+        base = read_range
+        children = (loc_children || []).map { |name, required| [name, required, read_range] }
+
+        return nil unless base
+
+        location = RBS::Location.new(@buffer, base[0], base[1])
+        children.each do |name, required, range|
+          if required
+            location.add_required_child(name, range[0]...range[1]) if range
+          else
+            location.add_optional_child(name, range ? (range[0]...range[1]) : nil)
+          end
+        end
+        location
+      end
+
+      # A standalone location range field: nil or an RBS::Location without children.
+      def read_location_value
+        range = read_range
+        range && RBS::Location.new(@buffer, range[0], range[1])
+      end
+
+      def read_location_value_list
+        Array.new(read_count) { read_location_value }
+      end
+
+      def read_attr_ivar_name
+        case read_u8
+        when 0 then nil   # inferred instance variable
+        when 1 then false # no instance variable
+        else read_string(@encoding).to_sym
+        end
+      end
+
+      # Reads a presence byte and, when present, the start/end character positions.
+      def read_range
+        return nil if read_u8 == 0
+
+        start_char = read_i32
+        end_char = read_i32
+        [start_char, end_char]
+      end
+
+      def read_u8
+        byte = @bytes.getbyte(@pos) or raise "Unexpected end of buffer"
+        @pos += 1
+        byte
+      end
+
+      def read_u32
+        value = @bytes.unpack1("L<", offset: @pos) #: Integer
+        @pos += 4
+        value
+      end
+
+      def read_i32
+        value = @bytes.unpack1("l<", offset: @pos) #: Integer
+        @pos += 4
+        value
+      end
+
+      def read_string(encoding)
+        length = read_u32
+        string = @bytes.byteslice(@pos, length) or raise "Unexpected end of buffer"
+        @pos += length
+        string.force_encoding(encoding)
+      end
+
+      def class_for(name)
+        @class_cache[name] ||= Object.const_get(name)
+      end
+    end
+  end
+end

data/lib/rbs/wasm/location.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RBS
+  # Pure-Ruby implementation of the primitives that back RBS::Location.
+  #
+  # On CRuby these come from the C extension (ext/rbs_extension/legacy_location.c).
+  # JRuby loads this instead, before rbs/location_aux.rb layers the public API on
+  # top, so RBS::Location behaves identically without the native extension.
+  class Location
+    attr_reader :buffer
+
+    def initialize(buffer, start_pos, end_pos)
+      @buffer = buffer
+      @start_pos = start_pos
+      @end_pos = end_pos
+      @required_children = {} #: Hash[Symbol, [ Integer, Integer ]]
+      @optional_children = {} #: Hash[Symbol, [ Integer, Integer ]?]
+    end
+
+    def _start_pos
+      @start_pos
+    end
+
+    def _end_pos
+      @end_pos
+    end
+
+    def _add_required_child(name, start_pos, end_pos)
+      @required_children[name] = [start_pos, end_pos]
+    end
+
+    def _add_optional_child(name, start_pos, end_pos)
+      @optional_children[name] = [start_pos, end_pos]
+    end
+
+    def _add_optional_no_child(name)
+      @optional_children[name] = nil
+    end
+
+    def _required_keys
+      @required_children.keys
+    end
+
+    def _optional_keys
+      @optional_children.keys
+    end
+
+    def [](name)
+      if (range = @required_children[name])
+        return Location.new(@buffer, range[0], range[1])
+      end
+
+      if @optional_children.key?(name)
+        range = @optional_children[name]
+        return range && Location.new(@buffer, range[0], range[1])
+      end
+
+      raise "Unknown child name given: #{name}"
+    end
+  end
+end