[Truffle] Fixed marshaling of Range.

jruby · Jan 5, 2016 · 258188f · eregon · Jan 6, 2016 · nirvdrum
1 parent d90481f
commit 258188f
Showing 5 changed files with 121 additions and 8 deletions.
diff --git a/spec/truffle/tags/core/marshal/dump_tags.txt b/spec/truffle/tags/core/marshal/dump_tags.txt
@@ -13,8 +13,6 @@ fails:Marshal.dump with a Hash dumps an extended Hash
 fails:Marshal.dump with a Struct dumps an extended Struct
 fails:Marshal.dump with an Object dumps an extended Object
 fails:Marshal.dump with an Object dumps a BasicObject subclass if it defines respond_to?
-fails:Marshal.dump with a Range dumps a Range inclusive of end (with indeterminant order)
-fails:Marshal.dump with a Range dumps a Range exclusive of end (with indeterminant order)
 fails:Marshal.dump with a Time dumps the zone and the offset
 fails:Marshal.dump with a Time dumps the zone, but not the offset if zone is UTC
 fails:Marshal.dump with an Exception dumps the message for the exception

diff --git a/spec/truffle/tags/core/marshal/load_tags.txt b/spec/truffle/tags/core/marshal/load_tags.txt
@@ -3,9 +3,6 @@ fails:Marshal.load calls the proc for recursively visited data
 fails:Marshal.load loads an array containing objects having _dump method, and with proc
 fails:Marshal.load loads an array containing objects having marshal_dump method, and with proc
 fails:Marshal.load loads an Array with proc
-fails:Marshal.load loads a 1..2
-fails:Marshal.load loads a 1...2
-fails:Marshal.load loads a 'a'..'b'
 fails:Marshal.load loads a Random
 fails:Marshal.load for an Array loads an array containing the same objects
 fails:Marshal.load for an Exception loads a marshalled exception with no message

diff --git a/spec/truffle/tags/core/marshal/restore_tags.txt b/spec/truffle/tags/core/marshal/restore_tags.txt
@@ -3,9 +3,6 @@ fails:Marshal.restore calls the proc for recursively visited data
 fails:Marshal.restore loads an array containing objects having _dump method, and with proc
 fails:Marshal.restore loads an array containing objects having marshal_dump method, and with proc
 fails:Marshal.restore loads an Array with proc
-fails:Marshal.restore loads a 1..2
-fails:Marshal.restore loads a 1...2
-fails:Marshal.restore loads a 'a'..'b'
 fails:Marshal.restore loads a Random
 fails:Marshal.restore for an Array loads an array containing the same objects
 fails:Marshal.restore for an Exception loads a marshalled exception with no message

diff --git a/truffle/src/main/ruby/core.rb b/truffle/src/main/ruby/core.rb
@@ -188,6 +188,7 @@ def self.omit(reason)
 #require_relative 'core/rubinius/common/lookup_table'
 require_relative 'core/rubinius/common/main'
 require_relative 'core/rubinius/common/marshal'
+require_relative 'core/rubinius/api/shims/marshal'
 #require_relative 'core/rubinius/common/math'
 #require_relative 'core/rubinius/common/method'
 #require_relative 'core/rubinius/common/method_equality'

diff --git a/truffle/src/main/ruby/core/rubinius/api/shims/marshal.rb b/truffle/src/main/ruby/core/rubinius/api/shims/marshal.rb
@@ -0,0 +1,120 @@
+# Copyright (c) 2007-2015, Evan Phoenix and contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of Rubinius nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Modifications are subject to:
+# Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 1.0
+# GNU General Public License version 2
+# GNU Lesser General Public License version 2.1
+
+class Range
+
+  # Custom marshal dumper for Range. Rubinius exposes the three main values in Range (begin, end, excl) as
+  # instance variables. MRI does not, but the values are encoded as instance variables within the marshal output from
+  # MRI, so they both generate the same output, with the exception of the ordering of the variables. In JRuby+Truffle,
+  # we do something more along the lines of MRI and as such, the default Rubinius handler for dumping Range doesn't
+  # work for us because there are no instance variables to dump. This custom dumper explicitly encodes the three main
+  # values so we generate the correct dump data.
+  def __marshal__(ms)
+    out = ms.serialize_extended_object self
+    out << "o"
+    cls = Rubinius::Type.object_class self
+    name = Rubinius::Type.module_inspect cls
+    out << ms.serialize(name.to_sym)
+    out << ms.serialize_integer(3 + self.instance_variables.size)
+    out << ms.serialize(:begin)
+    out << ms.serialize(self.begin)
+    out << ms.serialize(:end)
+    out << ms.serialize(self.end)
+    out << ms.serialize(:excl)
+    out << ms.serialize(self.exclude_end?)
+    out << ms.serialize_instance_variables_suffix(self, true, true)
+  end
+
+end
+
+module Marshal
+  class State
+
+    def construct_object
+      name = get_symbol
+      klass = const_lookup name, Class
+
+      if klass <= Range
+        construct_range(klass)
+      else
+        obj = klass.allocate
+
+        raise TypeError, 'dump format error' unless Object === obj
+
+        store_unique_object obj
+        if Rubinius::Type.object_kind_of? obj, Exception
+          set_exception_variables obj
+        else
+          set_instance_variables obj
+        end
+
+        obj
+      end
+    end
+
+    # Rubinius stores three main values in Range (begin, end, excl) as instance variables and as such, can use the
+    # normal, generic object deserializer. In JRuby+Truffle, we do not expose these values as instance variables, in
+    # keeping with MRI. Moreover, we have specialized versions of Ranges depending on these values, so changing them
+    # after object construction would create optimization problems. Instead, we patch the Rubinius marshal loader here
+    # to specifically handle Ranges by constructing a Range of the proper type using the deserialized main values and
+    # then setting any custom instance variables afterward.
+    def construct_range(klass)
+      range_begin = nil
+      range_end = nil
+      range_exclude_end = false
+      ivars = {}
+
+      construct_integer.times do
+        ivar = prepare_ivar(get_symbol)
+        value = construct
+
+        case ivar
+          when :@begin then range_begin = value
+          when :@end then range_end = value
+          when :@excl then range_exclude_end = value
+          else ivars[ivar] = value
+        end
+      end
+
+      range = klass.new(range_begin, range_end, range_exclude_end)
+      store_unique_object range
+
+      ivars.each { |name, value| range.__instance_variable_set__ name, value }
+
+      range
+    end
+
+  end
+end