Merge branch 'master' into pyvaluepayload

Author: coolreader18

tests/snippets/mro.py

@@ -18,3 +18,5 @@ class C(A, B):
     pass
 
 assert (C, A, B, X, Y, object) == C.__mro__
+
+assert type.__mro__ == (type, object)

tests/snippets/property.py

@@ -30,3 +30,18 @@ def foo(self):
 
 with assertRaises(TypeError):
     property.__new__(object)
+
+
+p1 = property("a", "b", "c")
+
+assert p1.fget == "a"
+assert p1.fset == "b"
+assert p1.fdel == "c"
+
+assert p1.getter(1).fget == 1
+assert p1.setter(2).fset == 2
+assert p1.deleter(3).fdel == 3
+
+assert p1.getter(None).fget == "a"
+assert p1.setter(None).fset == "b"
+assert p1.deleter(None).fdel == "c"

tests/snippets/subclass_str.py

@@ -0,0 +1,22 @@
+from testutils import assertRaises
+
+x = "An interesting piece of text"
+assert x is str(x)
+
+class Stringy(str):
+    def __new__(cls, value=""):
+        return str.__new__(cls, value)
+
+    def __init__(self, value):
+        self.x = "substr"
+
+y = Stringy(1)
+assert type(y) is Stringy, "Type of Stringy should be stringy"
+assert type(str(y)) is str, "Str of a str-subtype should be a str."
+
+assert y + " other" == "1 other"
+assert y.x == "substr"
+
+## Base strings currently get an attribute dict, but shouldn't.
+# with assertRaises(AttributeError):
+#     "hello".x = 5

vm/src/obj/objint.rs

@@ -24,11 +24,14 @@ pub struct PyInt {
 pub type PyIntRef = PyRef<PyInt>;
 
 impl PyInt {
-    pub fn new<T: ToBigInt>(i: T) -> Self {
-        PyInt {
-            // TODO: this .clone()s a BigInt, which is not what we want.
-            value: i.to_bigint().unwrap(),
-        }
+    pub fn new<T: Into<BigInt>>(i: T) -> Self {
+        PyInt { value: i.into() }
+    }
+}
+
+impl IntoPyObject for BigInt {
+    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
+        Ok(ctx.new_int(self))
     }
 }
 
@@ -315,8 +318,8 @@ impl PyIntRef {
         }
     }
 
-    fn neg(self, vm: &mut VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_int(-(&self.value))
+    fn neg(self, _vm: &mut VirtualMachine) -> BigInt {
+        -(&self.value)
     }
 
     fn hash(self, _vm: &mut VirtualMachine) -> u64 {
@@ -325,8 +328,8 @@ impl PyIntRef {
         hasher.finish()
     }
 
-    fn abs(self, vm: &mut VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_int(self.value.abs())
+    fn abs(self, _vm: &mut VirtualMachine) -> BigInt {
+        self.value.abs()
     }
 
     fn round(self, _precision: OptionalArg<PyObjectRef>, _vm: &mut VirtualMachine) -> Self {
@@ -337,8 +340,8 @@ impl PyIntRef {
         self.value.to_f64().unwrap()
     }
 
-    fn invert(self, vm: &mut VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_int(!(&self.value))
+    fn invert(self, _vm: &mut VirtualMachine) -> BigInt {
+        !(&self.value)
     }
 
     fn repr(self, _vm: &mut VirtualMachine) -> String {

vm/src/obj/objnone.rs

@@ -21,6 +21,15 @@ impl IntoPyObject for () {
     }
 }
 
+impl<T: IntoPyObject> IntoPyObject for Option<T> {
+    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
+        match self {
+            Some(x) => x.into_pyobject(ctx),
+            None => Ok(ctx.none()),
+        }
+    }
+}
+
 impl PyNoneRef {
     fn repr(self, _vm: &mut VirtualMachine) -> PyResult<String> {
         Ok("None".to_string())

vm/src/obj/objproperty.rs

@@ -2,8 +2,6 @@
 
 */
 
-use std::marker::PhantomData;
-
 use crate::obj::objstr::PyStringRef;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
@@ -67,6 +65,8 @@ impl PyPropertyRef {
         )
     }
 
+    // Descriptor methods
+
     fn get(self, obj: PyObjectRef, _owner: PyClassRef, vm: &mut VirtualMachine) -> PyResult {
         if let Some(getter) = self.getter.as_ref() {
             vm.invoke(getter.clone(), obj)
@@ -90,42 +90,90 @@ impl PyPropertyRef {
             Err(vm.new_attribute_error("can't delete attribute".to_string()))
         }
     }
+
+    // Access functions
+
+    fn fget(self, _vm: &mut VirtualMachine) -> Option<PyObjectRef> {
+        self.getter.clone()
+    }
+
+    fn fset(self, _vm: &mut VirtualMachine) -> Option<PyObjectRef> {
+        self.setter.clone()
+    }
+
+    fn fdel(self, _vm: &mut VirtualMachine) -> Option<PyObjectRef> {
+        self.deleter.clone()
+    }
+
+    // Python builder functions
+
+    fn getter(self, getter: Option<PyObjectRef>, vm: &mut VirtualMachine) -> PyResult<Self> {
+        Self::new_with_type(
+            vm,
+            PyProperty {
+                getter: getter.or_else(|| self.getter.clone()),
+                setter: self.setter.clone(),
+                deleter: self.deleter.clone(),
+            },
+            self.typ(),
+        )
+    }
+
+    fn setter(self, setter: Option<PyObjectRef>, vm: &mut VirtualMachine) -> PyResult<Self> {
+        Self::new_with_type(
+            vm,
+            PyProperty {
+                getter: self.getter.clone(),
+                setter: setter.or_else(|| self.setter.clone()),
+                deleter: self.deleter.clone(),
+            },
+            self.typ(),
+        )
+    }
+
+    fn deleter(self, deleter: Option<PyObjectRef>, vm: &mut VirtualMachine) -> PyResult<Self> {
+        Self::new_with_type(
+            vm,
+            PyProperty {
+                getter: self.getter.clone(),
+                setter: self.setter.clone(),
+                deleter: deleter.or_else(|| self.deleter.clone()),
+            },
+            self.typ(),
+        )
+    }
 }
 
-pub struct PropertyBuilder<'a, T> {
+pub struct PropertyBuilder<'a> {
     ctx: &'a PyContext,
     getter: Option<PyObjectRef>,
     setter: Option<PyObjectRef>,
-    _return: PhantomData<T>,
 }
 
-impl<'a, T> PropertyBuilder<'a, T> {
+impl<'a> PropertyBuilder<'a> {
     pub fn new(ctx: &'a PyContext) -> Self {
         Self {
             ctx,
             getter: None,
             setter: None,
-            _return: PhantomData,
         }
     }
 
-    pub fn add_getter<I, F: IntoPyNativeFunc<I, T>>(self, func: F) -> Self {
+    pub fn add_getter<I, V, F: IntoPyNativeFunc<I, V>>(self, func: F) -> Self {
         let func = self.ctx.new_rustfunc(func);
         Self {
             ctx: self.ctx,
             getter: Some(func),
             setter: self.setter,
-            _return: PhantomData,
         }
     }
 
-    pub fn add_setter<I, F: IntoPyNativeFunc<(I, T), PyResult>>(self, func: F) -> Self {
+    pub fn add_setter<I, V, F: IntoPyNativeFunc<(I, V), PyResult>>(self, func: F) -> Self {
         let func = self.ctx.new_rustfunc(func);
         Self {
             ctx: self.ctx,
             getter: self.getter,
             setter: Some(func),
-            _return: PhantomData,
         }
     }
 
@@ -190,5 +238,13 @@ pub fn init(context: &PyContext) {
         "__get__" => context.new_rustfunc(PyPropertyRef::get),
         "__set__" => context.new_rustfunc(PyPropertyRef::set),
         "__delete__" => context.new_rustfunc(PyPropertyRef::delete),
+
+        "fget" => context.new_property(PyPropertyRef::fget),
+        "fset" => context.new_property(PyPropertyRef::fset),
+        "fdel" => context.new_property(PyPropertyRef::fdel),
+
+        "getter" => context.new_rustfunc(PyPropertyRef::getter),
+        "setter" => context.new_rustfunc(PyPropertyRef::setter),
+        "deleter" => context.new_rustfunc(PyPropertyRef::deleter),
     });
 }

vm/src/obj/objstr.rs

@@ -7,15 +7,15 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::format::{FormatParseError, FormatPart, FormatString};
 use crate::pyobject::{
-    IntoPyObject, OptionalArg, PyContext, PyFuncArgs, PyIterable, PyObjectRef, PyRef, PyResult,
-    PyValue, TypeProtocol,
+    IdProtocol, IntoPyObject, OptionalArg, PyContext, PyFuncArgs, PyIterable, PyObjectRef, PyRef,
+    PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
 use super::objint;
 use super::objsequence::PySliceableSequence;
 use super::objslice::PySlice;
-use super::objtype;
+use super::objtype::{self, PyClassRef};
 
 #[derive(Clone, Debug)]
 pub struct PyString {
@@ -788,16 +788,21 @@ fn perform_format(
 // TODO: should with following format
 // class str(object='')
 // class str(object=b'', encoding='utf-8', errors='strict')
-fn str_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    if args.args.len() == 1 {
-        return Ok(vm.new_str("".to_string()));
-    }
-
-    if args.args.len() > 2 {
-        panic!("str expects exactly one parameter");
+fn str_new(
+    cls: PyClassRef,
+    object: OptionalArg<PyObjectRef>,
+    vm: &mut VirtualMachine,
+) -> PyResult<PyStringRef> {
+    let string = match object {
+        OptionalArg::Present(ref input) => vm.to_str(input)?,
+        OptionalArg::Missing => vm.new_str("".to_string()),
     };
-
-    vm.to_str(&args.args[1])
+    if string.typ().is(&cls) {
+        TryFromObject::try_from_object(vm, string)
+    } else {
+        let payload = string.payload::<PyString>().unwrap();
+        PyRef::new_with_type(vm, payload.clone(), cls)
+    }
 }
 
 impl PySliceableSequence for String {

vm/src/obj/objtype.rs

@@ -9,6 +9,7 @@ use crate::vm::VirtualMachine;
 
 use super::objdict;
 use super::objlist::PyList;
+use super::objproperty::PropertyBuilder;
 use super::objstr::{self, PyStringRef};
 use super::objtuple::PyTuple;
 
@@ -78,6 +79,10 @@ impl PyClassRef {
         PyTuple::from(elements)
     }
 
+    fn set_mro(self, _value: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
+        Err(vm.new_attribute_error("read-only attribute".to_string()))
+    }
+
     fn dir(self, vm: &mut VirtualMachine) -> PyList {
         let attributes = get_attributes(self);
         let attributes: Vec<PyObjectRef> = attributes
@@ -116,7 +121,11 @@ pub fn init(ctx: &PyContext) {
     extend_class!(&ctx, &ctx.type_type, {
         "__call__" => ctx.new_rustfunc(type_call),
         "__new__" => ctx.new_rustfunc(type_new),
-        "__mro__" => ctx.new_property(PyClassRef::mro),
+        "__mro__" =>
+            PropertyBuilder::new(ctx)
+                .add_getter(PyClassRef::mro)
+                .add_setter(PyClassRef::set_mro)
+                .create(),
         "__repr__" => ctx.new_rustfunc(PyClassRef::repr),
         "__prepare__" => ctx.new_rustfunc(PyClassRef::prepare),
         "__getattribute__" => ctx.new_rustfunc(type_getattribute),