[GR-16260] Avoid setting the class of a Ruby object.

PullRequest: truffleruby/874

Author: eregon

src/main/ruby/core/exception.rb

@@ -391,10 +391,7 @@ def self.new(*args)
         end
       end
 
-      error = allocate
-      Truffle::Internal::Unsafe.set_class error, self
-      Truffle.privately { error.initialize(*args) }
-      error
+      super(*args)
     end
   end
 

src/main/ruby/core/io.rb

@@ -805,27 +805,8 @@ def self.parse_mode(mode)
     ret
   end
 
-  def self.pipe(external=nil, internal=nil, options=nil)
-    fds = FFI::MemoryPointer.new(:int, 2) do |ptr|
-      r = Truffle::POSIX.pipe(ptr)
-      Errno.handle if r == -1
-      ptr.read_array_of_int(2)
-    end
-
-    lhs = self.new(fds[0], RDONLY)
-    rhs = self.new(fds[1], WRONLY)
-
-    lhs.close_on_exec = true
-    rhs.close_on_exec = true
-
-    lhs.set_encoding external || Encoding.default_external,
-                     internal || Encoding.default_internal, options
-
-    lhs.sync = true
-    rhs.sync = true
-
-    lhs.pipe = true
-    rhs.pipe = true
+  def self.pipe(external = nil, internal = nil, options = nil)
+    lhs, rhs = Truffle::IOOperations.create_pipe(self, self, external, internal, options)
 
     if block_given?
       begin
@@ -881,18 +862,16 @@ def self.popen(*args)
       readable = true
     end
 
-    pa_read, ch_write = pipe if readable
+    # We only need the Bidirectional pipe if we're reading and writing.
+    # Otherwise, we can just return the IO object for the proper half.
+    read_class = (readable && writable) ? IO::BidirectionalPipe : self
+
+    pa_read, ch_write = Truffle::IOOperations.create_pipe(read_class, self) if readable
     ch_read, pa_write = pipe if writable
 
-    # We only need the Bidirectional pipe if we're reading and writing.
-    # If we're only doing one, we can just return the IO object for
-    # the proper half.
     if readable and writable
-      # Transmogrify pa_read into a BidirectionalPipe object,
-      # and then tell it about its pid and pa_write
-      Truffle::Internal::Unsafe.set_class pa_read, IO::BidirectionalPipe
       pipe = pa_read
-      pipe.set_pipe_info(pa_write)
+      pipe.instance_variable_set(:@write, pa_write)
     elsif readable
       pipe = pa_read
     elsif writable
@@ -1149,7 +1128,7 @@ def self.setup(io, fd, mode=nil, sync=false)
     end
 
     # Close old descriptor if there was already one associated
-    io.close if io.descriptor
+    io.close if io.descriptor != -1
 
     io.descriptor = fd
     io.mode       = mode || cur_mode
@@ -2228,7 +2207,8 @@ def reopen(other, mode=undefined)
 
         Truffle::IOOperations.dup2_with_cloexec(io.fileno, @descriptor)
 
-        Truffle::Internal::Unsafe.set_class self, io.class
+        Truffle.invoke_primitive :vm_set_class, self, io.class
+
         if io.respond_to?(:path)
           @path = io.path
         end
@@ -2673,18 +2653,11 @@ def encode_with coder
 
 class IO::BidirectionalPipe < IO
 
-  def set_pipe_info(write)
-    @write = write
-    @sync = true
-  end
-
   ##
   # Closes ios and flushes any pending writes to the
   # operating system. The stream is unavailable for
   # any further data operations; an IOError is raised
-  # if such an attempt is made. I/O streams are
-  # automatically closed when they are claimed by
-  # the garbage collector.
+  # if such an attempt is made.
   #
   # If ios is opened by IO.popen, close sets $?.
   def close

src/main/ruby/core/marshal.rb

@@ -223,11 +223,29 @@ def set_instance_variables(obj)
       end
     end
 
+    STRING_ALLOCATE = String.method(:__allocate__).unbind
+
     def construct_string
-      obj = get_byte_sequence
-      Truffle::Internal::Unsafe.set_class(obj, get_user_class) if @user_class
+      bytes = get_byte_sequence.force_encoding(Encoding::ASCII_8BIT)
 
-      set_object_encoding(obj, Encoding::ASCII_8BIT)
+      if @user_class
+        cls = get_user_class
+        if cls < String
+          obj = STRING_ALLOCATE.bind(cls).call
+        else
+          allocate = cls.method(:__allocate__)
+          if allocate.unbind == STRING_ALLOCATE
+            # For example, String.clone falls in this case
+            obj = allocate.call
+          else
+            raise ArgumentError, 'dump format error (user class)'
+          end
+        end
+
+        Truffle.invoke_primitive(:string_initialize, obj, bytes, Encoding::ASCII_8BIT)
+      else
+        obj = bytes
+      end
 
       store_unique_object obj
     end
@@ -653,21 +671,24 @@ def construct_old_module
       obj
     end
 
+    ARRAY_ALLOCATE = Array.method(:__allocate__).unbind
     ARRAY_APPEND = Array.instance_method(:<<)
 
     def construct_array
-      obj = []
-      store_unique_object obj
-
       if @user_class
         cls = get_user_class()
         if cls < Array
-          Truffle::Internal::Unsafe.set_class obj, cls
+          obj = ARRAY_ALLOCATE.bind(cls).call
         else
           # This is what MRI does, it's weird.
-          return cls.allocate
+          obj = cls.allocate
+          store_unique_object obj
+          return obj
         end
+      else
+        obj = []
       end
+      store_unique_object obj
 
       construct_integer.times do |_i|
         ARRAY_APPEND.bind(obj).call(construct)

src/main/ruby/core/truffle/internal.rb

@@ -35,19 +35,6 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 module Truffle::Internal
-
-  module Unsafe
-    def self.set_class(obj, cls)
-      Truffle.primitive :vm_set_class
-
-      if obj.kind_of? ImmediateValue
-        raise TypeError, 'Can not change the class of an immediate'
-      end
-
-      raise ArgumentError, "Class #{cls} is not compatible with #{obj.inspect}"
-    end
-  end
-
   def self.get_data(path, offset)
     file = File.open(path)
     file.seek(offset)

src/main/ruby/core/truffle/io_operations.rb

@@ -13,10 +13,12 @@ module IOOperations
     def self.last_line(a_binding)
       Truffle::KernelOperations.frame_local_variable_get(:$_, a_binding)
     end
+    Truffle::Graal.always_split(method(:last_line))
 
     def self.set_last_line(value, a_binding)
       Truffle::KernelOperations.frame_local_variable_set(:$_, a_binding, value)
     end
+    Truffle::Graal.always_split(method(:set_last_line))
 
     def self.print(io, args, last_line_binding)
       if args.empty?
@@ -96,7 +98,27 @@ def self.dup2_with_cloexec(old_fd, new_fd)
       end
     end
 
-    Truffle::Graal.always_split(method(:last_line))
-    Truffle::Graal.always_split(method(:set_last_line))
+    def self.pipe_end_setup(io)
+      io.close_on_exec = true
+      io.sync = true
+      io.pipe = true
+      io
+    end
+
+    def self.create_pipe(read_class, write_class, external = nil, internal = nil, options = nil)
+      fds = Truffle::FFI::MemoryPointer.new(:int, 2) do |ptr|
+        res = Truffle::POSIX.pipe(ptr)
+        Errno.handle if res == -1
+        ptr.read_array_of_int(2)
+      end
+
+      lhs = pipe_end_setup(read_class.new(fds[0], IO::RDONLY))
+      rhs = pipe_end_setup(write_class.new(fds[1], IO::WRONLY))
+
+      lhs.set_encoding external || Encoding.default_external,
+                       internal || Encoding.default_internal, options
+
+      [lhs, rhs]
+    end
   end
 end