rbs 3.9.4 → 4.1.1

data/lib/rbs/types.rb

@@ -61,7 +61,7 @@ module RBS
         include EmptyEachType
         include NoTypeName
 
-        def to_json(state = _ = nil)
+        def to_json(state = nil)
           klass = to_s.to_sym
           { class: klass, location: location }.to_json(state)
         end
@@ -157,7 +157,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :variable, name: name, location: location }.to_json(state)
       end
 
@@ -199,58 +199,6 @@ module RBS
       end
     end
 
-    class ClassSingleton
-      attr_reader :name
-      attr_reader :location
-
-      def initialize(name:, location:)
-        @name = name
-        @location = location
-      end
-
-      def ==(other)
-        other.is_a?(ClassSingleton) && other.name == name
-      end
-
-      alias eql? ==
-
-      def hash
-        self.class.hash ^ name.hash
-      end
-
-      include NoFreeVariables
-      include NoSubst
-
-      def to_json(state = _ = nil)
-        { class: :class_singleton, name: name, location: location }.to_json(state)
-      end
-
-      def to_s(level = 0)
-        "singleton(#{name})"
-      end
-
-      include EmptyEachType
-
-      def map_type_name(&)
-        ClassSingleton.new(
-          name: yield(name, location, self),
-          location: location
-        )
-      end
-
-      def has_self_type?
-        false
-      end
-
-      def has_classish_type?
-        false
-      end
-
-      def with_nonreturn_void?
-        false
-      end
-    end
-
     module Application
       attr_reader :name
       attr_reader :args
@@ -303,12 +251,74 @@ module RBS
             # `void` in immediate generics parameter is allowed
             false
           else
-            type.with_nonreturn_void?
+            type.with_nonreturn_void? # steep:ignore DeprecatedReference
           end
         end
       end
     end
 
+    class ClassSingleton
+      attr_reader :location
+
+      include Application
+
+      def initialize(name:, location:, args: [])
+        @name = name
+        @location = location
+        @args = args
+      end
+
+      def ==(other)
+        other.is_a?(ClassSingleton) && other.name == name && other.args == args
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ args.hash
+      end
+
+      def sub(s)
+        return self if s.empty?
+
+        self.class.new(name: name,
+                       args: args.map {|ty| ty.sub(s) },
+                       location: location)
+      end
+
+      def to_json(state = _ = nil)
+        { class: :class_singleton, name: name, args: args, location: location }.to_json(state)
+      end
+
+      def to_s(level = 0)
+        if args.empty?
+          "singleton(#{name})"
+        else
+          "singleton(#{name})[#{args.join(", ")}]"
+        end
+      end
+
+      def map_type_name(&block)
+        ClassSingleton.new(
+          name: yield(name, location, self),
+          args: args.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
+
+      def map_type(&block)
+        if block
+          ClassSingleton.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
+    end
+
     class Interface
       attr_reader :location
 
@@ -320,7 +330,7 @@ module RBS
         @location = location
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :interface, name: name, args: args, location: location }.to_json(state)
       end
 
@@ -364,7 +374,7 @@ module RBS
         @location = location
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :class_instance, name: name, args: args, location: location }.to_json(state)
       end
 
@@ -408,7 +418,7 @@ module RBS
         @location = location
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :alias, name: name, args: args, location: location }.to_json(state)
       end
 
@@ -466,7 +476,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :tuple, types: types, location: location }.to_json(state)
       end
 
@@ -520,7 +530,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        each_type.any? {|type| type.with_nonreturn_void? }
+        each_type.any? {|type| type.with_nonreturn_void? } # steep:ignore DeprecatedReference
       end
     end
 
@@ -573,7 +583,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :record, fields: fields, optional_fields: optional_fields, location: location }.to_json(state)
       end
 
@@ -638,7 +648,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        each_type.any? {|type| type.with_nonreturn_void? }
+        each_type.any? {|type| type.with_nonreturn_void? } # steep:ignore DeprecatedReference
       end
     end
 
@@ -665,7 +675,7 @@ module RBS
         type.free_variables(set)
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :optional, type: type, location: location }.to_json(state)
       end
 
@@ -724,7 +734,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        each_type.any? {|type| type.with_nonreturn_void? }
+        each_type.any? {|type| type.with_nonreturn_void? } # steep:ignore DeprecatedReference
       end
     end
 
@@ -755,7 +765,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :union, types: types, location: location }.to_json(state)
       end
 
@@ -815,7 +825,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        each_type.any? {|type| type.with_nonreturn_void? }
+        each_type.any? {|type| type.with_nonreturn_void? } # steep:ignore DeprecatedReference
       end
     end
 
@@ -846,7 +856,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :intersection, types: types, location: location }.to_json(state)
       end
 
@@ -898,7 +908,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        each_type.any? {|type| type.with_nonreturn_void? }
+        each_type.any? {|type| type.with_nonreturn_void? } # steep:ignore DeprecatedReference
       end
     end
 
@@ -932,7 +942,7 @@ module RBS
           end
         end
 
-        def to_json(state = _ = nil)
+        def to_json(state = nil)
           { type: type, name: name }.to_json(state)
         end
 
@@ -1091,7 +1101,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         {
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -1226,13 +1236,13 @@ module RBS
       end
 
       def with_nonreturn_void?
-        if each_param.any? {|param| param.type.with_nonreturn_void? }
+        if each_param.any? {|param| param.type.with_nonreturn_void? } # steep:ignore DeprecatedReference
           true
         else
           if return_type.is_a?(Bases::Void)
             false
           else
-            return_type.with_nonreturn_void?
+            return_type.with_nonreturn_void? # steep:ignore DeprecatedReference
           end
         end
       end
@@ -1279,7 +1289,7 @@ module RBS
         end
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         {
           return_type: return_type
         }.to_json(state)
@@ -1339,8 +1349,10 @@ module RBS
       attr_reader :type
       attr_reader :required
       attr_reader :self_type
+      attr_reader :location
 
-      def initialize(type:, required:, self_type: nil)
+      def initialize(location: nil, type:, required:, self_type: nil)
+        @location = location
         @type = type
         @required = required ? true : false
         @self_type = self_type
@@ -1353,7 +1365,7 @@ module RBS
           other.self_type == self_type
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         {
           type: type,
           required: required,
@@ -1422,7 +1434,7 @@ module RBS
         set
       end
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         {
           class: :proc,
           type: type,
@@ -1503,11 +1515,11 @@ module RBS
       end
 
       def with_nonreturn_void?
-        if type.with_nonreturn_void? || self_type&.with_nonreturn_void?
+        if type.with_nonreturn_void? || self_type&.with_nonreturn_void? # steep:ignore DeprecatedReference
           true
         else
           if block = block()
-            block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false
+            block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false # steep:ignore DeprecatedReference
           else
             false
           end
@@ -1539,7 +1551,7 @@ module RBS
       include EmptyEachType
       include NoTypeName
 
-      def to_json(state = _ = nil)
+      def to_json(state = nil)
         { class: :literal, literal: literal.inspect, location: location }.to_json(state)
       end
 

data/lib/rbs/unit_test/convertibles.rb

@@ -5,6 +5,7 @@ module RBS
     module Convertibles
       class BlankSlate < BasicObject
         instance_methods.each do |im|
+          next if im == :__id__
           next if im == :__send__
           undef_method im
         end

data/lib/rbs/unit_test/type_assertions.rb

@@ -192,6 +192,31 @@ module RBS
         end
       end
 
+      ruby2_keywords def assert_send_type_error(method_type, error_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: [],
+            instance_class: instance_class,
+            class_class: class_class
+          )
+          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}"
+
+          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(" | ")}"
+
+          # Use `instnace_of?` instead of `is_a?` as we want to check for _the exact exception class_.
+          assert exception.instance_of? error_type
+
+          result
+        end
+      end
+
       ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
         send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
           method_type = method_type.update(
@@ -231,15 +256,17 @@ module RBS
         type, definition = target
 
         case type
-        when Types::ClassInstance
-          subst = RBS::Substitution.build(definition.type_params, type.args)
-          definition.methods[method].defs.map do |type_def|
-            type_def.update(
-              type: type_def.type.sub(subst)
-            )
+        when Types::ClassInstance, Types::ClassSingleton
+          if type.is_a?(Types::ClassSingleton) && type.args.empty?
+            definition.methods[method].defs
+          else
+            subst = RBS::Substitution.build(definition.type_params, type.args)
+            definition.methods[method].defs.map do |type_def|
+              type_def.update(
+                type: type_def.type.sub(subst)
+              )
+            end
           end
-        when Types::ClassSingleton
-          definition.methods[method].defs
         else
           raise
         end
@@ -296,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/validator.rb

@@ -127,8 +127,8 @@ module RBS
       # @type var each_child: ^(Symbol) { (Symbol) -> void } -> void
       each_child = -> (name, &block) do
         if param = params.find {|p| p.name == name }
-          if b = param.upper_bound_type
-            b.free_variables.each do |tv|
+          [param.upper_bound_type, param.lower_bound_type].compact.each do |bound|
+            bound.free_variables.each do |tv|
               block[tv]
             end
           end

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.9.4"
+  VERSION = "4.1.1"
 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