Implement object.__reduce__

coolreader18 · coolreader18 · commit 79b75b681634 · 2019-10-10T21:10:16.000-05:00
diff --git a/vm/Lib/__reducelib.py b/vm/Lib/__reducelib.py
@@ -0,0 +1,86 @@
+# Modified from code from the PyPy project:
+# https://bitbucket.org/pypy/pypy/src/default/pypy/objspace/std/objectobject.py
+
+# The MIT License
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+import copyreg
+
+
+def _abstract_method_error(typ):
+    methods = ", ".join(sorted(typ.__abstractmethods__))
+    err = "Can't instantiate abstract class %s with abstract methods %s"
+    raise TypeError(err % (typ.__name__, methods))
+
+
+def reduce_2(obj):
+    cls = obj.__class__
+
+    try:
+        getnewargs = obj.__getnewargs__
+    except AttributeError:
+        args = ()
+    else:
+        args = getnewargs()
+        if not isinstance(args, tuple):
+            raise TypeError("__getnewargs__ should return a tuple")
+
+    try:
+        getstate = obj.__getstate__
+    except AttributeError:
+        state = getattr(obj, "__dict__", None)
+        names = slotnames(cls)  # not checking for list
+        if names is not None:
+            slots = {}
+            for name in names:
+                try:
+                    value = getattr(obj, name)
+                except AttributeError:
+                    pass
+                else:
+                    slots[name] = value
+            if slots:
+                state = state, slots
+    else:
+        state = getstate()
+
+    listitems = iter(obj) if isinstance(obj, list) else None
+    dictitems = obj.iteritems() if isinstance(obj, dict) else None
+
+    newobj = copyreg.__newobj__
+
+    args2 = (cls,) + args
+    return newobj, args2, state, listitems, dictitems
+
+
+def slotnames(cls):
+    if not isinstance(cls, type):
+        return None
+
+    try:
+        return cls.__dict__["__slotnames__"]
+    except KeyError:
+        pass
+
+    slotnames = copyreg._slotnames(cls)
+    if not isinstance(slotnames, list) and slotnames is not None:
+        raise TypeError("copyreg._slotnames didn't return a list or None")
+    return slotnames
diff --git a/vm/src/frozen.rs b/vm/src/frozen.rs
@@ -15,10 +15,18 @@ pub fn get_module_inits() -> HashMap<String, FrozenModule> {
         file = "Lib/_bootstrap_external.py",
         module_name = "_frozen_importlib_external",
     ));
+    modules.extend(py_compile_bytecode!(
+        file = "../Lib/copyreg.py",
+        module_name = "copyreg",
+    ));
+    modules.extend(py_compile_bytecode!(
+        file = "Lib/__reducelib.py",
+        module_name = "__reducelib",
+    ));
 
     #[cfg(feature = "freeze-stdlib")]
     {
-        modules.extend(py_compile_bytecode!(dir = "../Lib/",));
+        modules.extend(py_compile_bytecode!(dir = "../Lib/"));
     }
 
     modules
diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -1,10 +1,9 @@
 use super::objdict::PyDictRef;
 use super::objlist::PyList;
 use super::objstr::PyStringRef;
-use super::objtype;
-use crate::function::PyFuncArgs;
+use super::objtype::{self, PyClassRef};
+use crate::function::{OptionalArg, PyFuncArgs};
 use crate::obj::objproperty::PropertyBuilder;
-use crate::obj::objtype::PyClassRef;
 use crate::pyhash;
 use crate::pyobject::{
     IdProtocol, ItemProtocol, PyAttributes, PyContext, PyObject, PyObjectRef, PyResult, PyValue,
@@ -186,6 +185,8 @@ pub fn init(context: &PyContext) {
         "__format__" => context.new_rustfunc(object_format),
         "__getattribute__" => context.new_rustfunc(object_getattribute),
         "__subclasshook__" => context.new_classmethod(object_subclasshook),
+        "__reduce__" => context.new_rustfunc(object_reduce),
+        "__reduce_ex__" => context.new_rustfunc(object_reduce_ex),
         "__doc__" => context.new_str(object_doc.to_string()),
     });
 }
@@ -211,7 +212,7 @@ fn object_dict(object: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyDictRef>
     if let Some(ref dict) = object.dict {
         Ok(dict.clone())
     } else {
-        Err(vm.new_type_error("TypeError: no dictionary.".to_string()))
+        Err(vm.new_attribute_error("no dictionary.".to_string()))
     }
 }
 
@@ -230,3 +231,31 @@ fn object_getattribute(obj: PyObjectRef, name: PyStringRef, vm: &VirtualMachine)
     vm.generic_getattribute(obj.clone(), name.clone())?
         .ok_or_else(|| vm.new_attribute_error(format!("{} has no attribute '{}'", obj, name)))
 }
+
+fn object_reduce(obj: PyObjectRef, proto: OptionalArg<usize>, vm: &VirtualMachine) -> PyResult {
+    common_reduce(obj, proto.unwrap_or(0), vm)
+}
+
+fn object_reduce_ex(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+    let cls = obj.class();
+    if let Some(reduce) = objtype::class_get_attr(&cls, "__reduce__") {
+        let object_reduce =
+            objtype::class_get_attr(&vm.ctx.types.object_type, "__reduce__").unwrap();
+        if !reduce.is(&object_reduce) {
+            return vm.invoke(&reduce, vec![]);
+        }
+    }
+    common_reduce(obj, proto, vm)
+}
+
+fn common_reduce(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+    if proto >= 2 {
+        let reducelib = vm.import("__reducelib", &[], 0)?;
+        let reduce_2 = vm.get_attribute(reducelib, "reduce_2")?;
+        vm.invoke(&reduce_2, vec![obj])
+    } else {
+        let copyreg = vm.import("copyreg", &[], 0)?;
+        let reduce_ex = vm.get_attribute(copyreg, "_reduce_ex")?;
+        vm.invoke(&reduce_ex, vec![obj, vm.new_int(proto)])
+    }
+}
