Implement the Data class from Ruby 3.2

Co-authored-by: Benoit Daloze <benoit.daloze@oracle.com>

Author: moste00

CHANGELOG.md

@@ -23,6 +23,7 @@ Compatibility:
 * Display "unhandled exception" as the message for `RuntimeError` instances with an empty message (#3255, @nirvdrum).
 * Set `RbConfig::CONFIG['configure_args']` for openssl and libyaml (#3170, #3303, @eregon).
 * Support `Socket.sockaddr_in(port, Socket::INADDR_ANY)` (#3361, @mtortonesi).
+* Implement the `Data` class from Ruby 3.2 (#3039, @moste00, @eregon).
 
 Performance:
 

lib/mri/pp.rb

@@ -419,7 +419,7 @@ def pretty_print_cycle(q) # :nodoc:
 class Data # :nodoc:
   def pretty_print(q) # :nodoc:
     q.group(1, sprintf("#<data %s", PP.mcall(self, Kernel, :class).name), '>') {
-      q.seplist(PP.mcall(self, Data, :members), lambda { q.text "," }) {|member|
+      q.seplist(PP.mcall(self, Kernel, :class).members, lambda { q.text "," }) {|member|
         q.breakable
         q.text member.to_s
         q.text '='

spec/tags/core/data/define_tags.txt

@@ -1188,6 +1188,16 @@ int sourceLine() {
 
     }
 
+    @CoreMethod(names = "rb_is_local_id", onSingleton = true, required = 1)
+    public abstract static class IsLocalIdNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization
+        boolean isLocalId(RubySymbol symbol) {
+            return symbol.getType() == IdentifierType.LOCAL;
+        }
+
+    }
+
     @CoreMethod(names = "rb_is_instance_id", onSingleton = true, required = 1)
     public abstract static class IsInstanceIdNode extends CoreMethodArrayArgumentsNode {
 

spec/tags/core/data/initialize_tags.txt

@@ -1048,9 +1048,10 @@ public boolean isTruffleBootMainMethod(SharedMethodInfo info) {
             "/core/truffle/polyglot.rb",
             "/core/truffle/polyglot_methods.rb",
             "/core/posix.rb",
+            "/core/data.rb",
+            "/core/truffle/queue_operations.rb",
             "/core/main.rb",
             "/core/post.rb",
-            "/core/truffle/queue_operations.rb",
             POST_BOOT_FILE
     };
 

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Truffle
+  module DataOperations
+    def self.unknown_keywords_message(given, object)
+      unknowns = given - Primitive.class(object)::CLASS_MEMBERS
+      s = 's' if unknowns.size > 1
+      "unknown keyword#{s}: #{unknowns.map(&:inspect).join ', '}"
+    end
+
+    def self.missing_keywords_message(given, object)
+      missing = Primitive.class(object)::CLASS_MEMBERS - given
+      s = 's' if missing.size > 1
+      "missing keyword#{s}: #{missing.map(&:inspect).join ', '}"
+    end
+  end
+end
+
+class Data
+  # The entire API of Data is this single class method
+  def self.define(*class_members, &block)
+    members_hash = {}
+    class_members.each do |m|
+      member = Truffle::Type.symbol_or_string_to_symbol(m)
+
+      raise ArgumentError, "invalid data member: #{member}" if member.end_with?('=')
+      raise ArgumentError, "duplicate member: #{member}" if members_hash[member]
+      members_hash[member] = true
+    end
+
+    members = members_hash.keys
+    members.freeze
+    members_hash.freeze
+
+    klass = Class.new self do
+      const_set :CLASS_MEMBERS, members
+      const_set :CLASS_MEMBERS_HASH, members_hash
+
+      def self.members
+        self::CLASS_MEMBERS.dup
+      end
+
+      class << self
+        define_method(:__allocate__, BasicObject.method(:__allocate__))
+
+        undef_method :define
+      end
+
+      def self.new(*args, **kwargs)
+        if !args.empty? and !kwargs.empty?
+          raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 0)"
+        end
+
+        instance = allocate
+
+        if !kwargs.empty?
+          instance.send(:initialize, **kwargs)
+        else
+          if args.size > self::CLASS_MEMBERS.size
+            raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..#{self::CLASS_MEMBERS.size})"
+          end
+
+          kwargs_for_initialize = {}
+          args.each_with_index do |arg, i|
+            kwargs_for_initialize[self::CLASS_MEMBERS[i]] = arg
+          end
+
+          instance.send(:initialize, **kwargs_for_initialize)
+        end
+
+        instance
+      end
+      singleton_class.alias_method :[], :new
+
+      # As an exception, these instance methods are directly defined on the returned class, like in CRuby.
+      # The reason is CRuby does not use an extra module so it needs to define these instance methods on the returned class.
+      members.each do |member|
+        define_method(member) { Primitive.object_hidden_var_get(self, member) }
+      end
+    end
+
+    # Instance methods are defined in an included module, so it is possible, e.g.,
+    # to redefine #initialize in the returned Data subclass and use super() to use the #initialize just below.
+    # CRuby defines these directly on Data, but that is suboptimal for performance.
+    # We want to have a specialized copy of these methods for each Data subclass.
+    instance_methods_module = Module.new do
+      def initialize(**kwargs)
+        members_hash = Primitive.class(self)::CLASS_MEMBERS_HASH
+        kwargs.each do |member, value|
+          if members_hash.include?(member)
+            Primitive.object_hidden_var_set(self, member, value)
+          else
+            raise ArgumentError, Truffle::DataOperations.unknown_keywords_message(kwargs.keys, self)
+          end
+        end
+
+        if kwargs.size < members_hash.size
+          raise ArgumentError, Truffle::DataOperations.missing_keywords_message(kwargs.keys, self)
+        end
+        Primitive.freeze(self)
+      end
+
+      def initialize_copy(other)
+        Primitive.class(other)::CLASS_MEMBERS.each do |member|
+          Primitive.object_hidden_var_set self, member, Primitive.object_hidden_var_get(other, member)
+        end
+        Primitive.freeze(self)
+        self
+      end
+
+      def members
+        Primitive.class(self).members
+      end
+
+      def to_h(&block)
+        h = {}
+        Primitive.class(self)::CLASS_MEMBERS.each do |member|
+          h[member] = Primitive.object_hidden_var_get(self, member)
+        end
+        h.to_h(&block)
+      end
+
+      def with(**changes)
+        return self if changes.empty?
+
+        h = to_h
+        changes.each_pair do |key, value|
+          if h.include?(key)
+            h[key] = value
+          else
+            raise ArgumentError, Truffle::DataOperations.unknown_keywords_message(changes.keys, self)
+          end
+        end
+        Primitive.class(self).new(**h)
+      end
+
+      def inspect
+        klass = Primitive.class(self)
+        class_name = Primitive.module_anonymous?(klass) ? '' : "#{Primitive.module_name(klass)} "
+        members_and_values = to_h.map do |member, value|
+          if Truffle::CExt.rb_is_local_id(member) or Truffle::CExt.rb_is_const_id(member)
+            "#{member}=#{value.inspect}"
+          else
+            "#{member.inspect}=#{value.inspect}"
+          end
+        end
+        "#<data #{class_name}#{members_and_values.join(', ')}>"
+      end
+      alias_method :to_s, :inspect
+
+      def deconstruct
+        Primitive.class(self)::CLASS_MEMBERS.map do |member|
+          Primitive.object_hidden_var_get(self, member)
+        end
+      end
+
+      def deconstruct_keys(keys)
+        return to_h if Primitive.nil?(keys)
+        raise TypeError, "wrong argument type #{Primitive.class(keys)} (expected Array or nil)" unless Primitive.is_a?(keys, Array)
+
+        members_hash = Primitive.class(self)::CLASS_MEMBERS_HASH
+        return {} if members_hash.size < keys.size
+
+        h = {}
+        keys.each do |requested_key|
+          case requested_key
+          when Symbol
+            symbolized_key = requested_key
+          when String
+            symbolized_key = requested_key.to_sym
+          end
+
+          if members_hash.include?(symbolized_key)
+            h[requested_key] = Primitive.object_hidden_var_get(self, symbolized_key)
+          else
+            return h
+          end
+        end
+        h
+      end
+
+      def ==(other)
+        return true if Primitive.equal?(self, other)
+        return false unless Primitive.class(self) == Primitive.class(other)
+
+        Truffle::ThreadOperations.detect_pair_recursion self, other do
+          return self.deconstruct == other.deconstruct
+        end
+
+        # Subtle: if we are here, we are recursing and haven't found any difference, so:
+        true
+      end
+
+      def eql?(other)
+        return true if Primitive.equal?(self, other)
+        return false unless Primitive.class(self) == Primitive.class(other)
+
+        Truffle::ThreadOperations.detect_pair_recursion self, other do
+          return self.deconstruct.eql?(other.deconstruct)
+        end
+
+        # Subtle: if we are here, we are recursing and haven't found any difference, so:
+        true
+      end
+
+      def hash
+        klass = Primitive.class(self)
+        members = klass::CLASS_MEMBERS
+
+        val = Primitive.vm_hash_start(klass.hash)
+        val = Primitive.vm_hash_update(val, members.size)
+
+        return val if Truffle::ThreadOperations.detect_outermost_recursion self do
+          members.each do |member|
+            member_hash = Primitive.object_hidden_var_get(self, member).hash
+            val = Primitive.vm_hash_update(val, member_hash)
+          end
+        end
+
+        Primitive.vm_hash_end(val)
+      end
+    end
+
+    klass.include instance_methods_module
+
+    klass.module_eval(&block) if block
+
+    klass
+  end
+
+  class << self
+    undef_method :new
+  end
+
+  def self.__allocate__
+    raise TypeError, "allocator undefined for #{self}"
+  end
+end

src/main/java/org/truffleruby/core/CoreLibrary.java

@@ -48,20 +48,7 @@ def self.new(klass_name, *attrs, keyword_init: nil, &block)
       end
     end
 
-    attrs = attrs.map do |a|
-      case a
-      when Symbol
-        a
-      when String
-        sym = a.to_sym
-        unless Primitive.is_a?(sym, Symbol)
-          raise TypeError, "#to_sym didn't return a symbol"
-        end
-        sym
-      else
-        raise TypeError, "#{a.inspect} is not a symbol"
-      end
-    end
+    attrs = attrs.map { |a| Truffle::Type.symbol_or_string_to_symbol(a) }
 
     duplicates = attrs.uniq!
     if duplicates
@@ -354,6 +341,7 @@ def to_a
   def deconstruct_keys(keys)
     return to_h if Primitive.nil?(keys)
     raise TypeError, "wrong argument type #{Primitive.class(keys)} (expected Array or nil)" unless Primitive.is_a?(keys, Array)
+
     return {} if self.length < keys.length
 
     h = {}

src/main/ruby/truffleruby/core/data.rb

@@ -449,6 +449,19 @@ def self.coerce_to_symbol(obj)
       end
     end
 
+    def self.symbol_or_string_to_symbol(obj)
+      case obj
+      when Symbol
+        obj
+      when String
+        sym = obj.to_sym
+        raise TypeError, "#to_sym didn't return a symbol" unless Primitive.is_a?(sym, Symbol)
+        sym
+      else
+        raise TypeError, "#{obj.inspect} is not a symbol"
+      end
+    end
+
     # Equivalent of num_exact in MRI's time.c, used by Time methods.
     def self.coerce_to_exact_num(obj)
       if Primitive.is_a? obj, Integer