Merge pull request RustPython#707 from RustPython/joey/proper-pyref-display

OddCoincidence · web-flow · commit 90db9812e5e2 · 2019-03-21T09:32:02.000-07:00
Fix the Display impl for PyRef
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -245,57 +245,62 @@ impl PyListRef {
         }
     }
 
-    fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if self.as_object().is(&other) {
-            return Ok(true);
+            return Ok(vm.new_bool(true));
         }
 
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_equal(vm, &zelf, &other)?)
+            let res = seq_equal(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Ok(false)
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_lt(vm, &zelf, &other)?)
+            let res = seq_lt(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '<'", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_gt(vm, &zelf, &other)?)
+            let res = seq_gt(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '>'", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_ge(vm, &zelf, &other)?)
+            let res = seq_ge(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '>='", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.list_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_le(vm, &zelf, &other)?)
+            let res = seq_le(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '<='", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 }
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -1,3 +1,4 @@
+use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::ops::Range;
 use std::str::FromStr;
@@ -26,11 +27,9 @@ pub struct PyString {
 }
 pub type PyStringRef = PyRef<PyString>;
 
-impl<T: ToString> From<T> for PyString {
-    fn from(t: T) -> PyString {
-        PyString {
-            value: t.to_string(),
-        }
+impl fmt::Display for PyString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.value, f)
     }
 }
 
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -46,43 +46,47 @@ impl PyValue for PyTuple {
 pub type PyTupleRef = PyRef<PyTuple>;
 
 impl PyTupleRef {
-    fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_lt(vm, &zelf, &other)?)
+            let res = seq_lt(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '<'", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_gt(vm, &zelf, &other)?)
+            let res = seq_gt(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '>'", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_ge(vm, &zelf, &other)?)
+            let res = seq_ge(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '>='", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
-    fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
             let zelf = self.elements.borrow();
             let other = get_elements(&other);
-            Ok(seq_le(vm, &zelf, &other)?)
+            let res = seq_le(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Err(vm.new_type_error(format!("Cannot compare {} and {} using '<='", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
@@ -93,7 +97,7 @@ impl PyTupleRef {
             let elements = e1.iter().chain(e2.iter()).cloned().collect();
             Ok(vm.ctx.new_tuple(elements))
         } else {
-            Err(vm.new_type_error(format!("Cannot add {} and {}", self, other)))
+            Ok(vm.ctx.not_implemented())
         }
     }
 
@@ -112,13 +116,14 @@ impl PyTupleRef {
         Ok(count)
     }
 
-    fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {
+    fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
         if objtype::isinstance(&other, &vm.ctx.tuple_type()) {
             let zelf = &self.elements.borrow();
             let other = get_elements(&other);
-            seq_equal(vm, &zelf, &other)
+            let res = seq_equal(vm, &zelf, &other)?;
+            Ok(vm.new_bool(res))
         } else {
-            Ok(false)
+            Ok(vm.ctx.not_implemented())
         }
     }
 
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
+use std::fmt;
 
 use crate::function::PyFuncArgs;
 use crate::pyobject::{
@@ -20,6 +21,12 @@ pub struct PyClass {
     pub mro: Vec<PyClassRef>,
 }
 
+impl fmt::Display for PyClass {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.name, f)
+    }
+}
+
 pub type PyClassRef = PyRef<PyClass>;
 
 impl PyValue for PyClass {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -768,9 +768,13 @@ impl<T> IntoPyObject for PyRef<T> {
     }
 }
 
-impl<T> fmt::Display for PyRef<T> {
+impl<T: fmt::Display> fmt::Display for PyRef<T>
+where
+    T: PyValue + fmt::Display,
+{
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.obj.fmt(f)
+        let value: &T = self.obj.payload().expect("unexpected payload for type");
+        fmt::Display::fmt(value, f)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -245,57 +245,62 @@ impl PyListRef {`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
`248`		`- fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {`
	`248`	`+ fn eq(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {`
`249`	`249`	`if self.as_object().is(&other) {`
`250`		`- return Ok(true);`
	`250`	`+ return Ok(vm.new_bool(true));`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`if objtype::isinstance(&other, &vm.ctx.list_type()) {`
`254`	`254`	`let zelf = self.elements.borrow();`
`255`	`255`	`let other = get_elements(&other);`
`256`		`- Ok(seq_equal(vm, &zelf, &other)?)`
	`256`	`+ let res = seq_equal(vm, &zelf, &other)?;`
	`257`	`+ Ok(vm.new_bool(res))`
`257`	`258`	`} else {`
`258`		`- Ok(false)`
	`259`	`+ Ok(vm.ctx.not_implemented())`
`259`	`260`	`}`
`260`	`261`	`}`
`261`	`262`
`262`		`- fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {`
	`263`	`+ fn lt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {`
`263`	`264`	`if objtype::isinstance(&other, &vm.ctx.list_type()) {`
`264`	`265`	`let zelf = self.elements.borrow();`
`265`	`266`	`let other = get_elements(&other);`
`266`		`- Ok(seq_lt(vm, &zelf, &other)?)`
	`267`	`+ let res = seq_lt(vm, &zelf, &other)?;`
	`268`	`+ Ok(vm.new_bool(res))`
`267`	`269`	`} else {`
`268`		`- Err(vm.new_type_error(format!("Cannot compare {} and {} using '<'", self, other)))`
	`270`	`+ Ok(vm.ctx.not_implemented())`
`269`	`271`	`}`
`270`	`272`	`}`
`271`	`273`
`272`		`- fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {`
	`274`	`+ fn gt(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {`
`273`	`275`	`if objtype::isinstance(&other, &vm.ctx.list_type()) {`
`274`	`276`	`let zelf = self.elements.borrow();`
`275`	`277`	`let other = get_elements(&other);`
`276`		`- Ok(seq_gt(vm, &zelf, &other)?)`
	`278`	`+ let res = seq_gt(vm, &zelf, &other)?;`
	`279`	`+ Ok(vm.new_bool(res))`
`277`	`280`	`} else {`
`278`		`- Err(vm.new_type_error(format!("Cannot compare {} and {} using '>'", self, other)))`
	`281`	`+ Ok(vm.ctx.not_implemented())`
`279`	`282`	`}`
`280`	`283`	`}`
`281`	`284`
`282`		`- fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {`
	`285`	`+ fn ge(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {`
`283`	`286`	`if objtype::isinstance(&other, &vm.ctx.list_type()) {`
`284`	`287`	`let zelf = self.elements.borrow();`
`285`	`288`	`let other = get_elements(&other);`
`286`		`- Ok(seq_ge(vm, &zelf, &other)?)`
	`289`	`+ let res = seq_ge(vm, &zelf, &other)?;`
	`290`	`+ Ok(vm.new_bool(res))`
`287`	`291`	`} else {`
`288`		`- Err(vm.new_type_error(format!("Cannot compare {} and {} using '>='", self, other)))`
	`292`	`+ Ok(vm.ctx.not_implemented())`
`289`	`293`	`}`
`290`	`294`	`}`
`291`	`295`
`292`		`- fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult<bool> {`
	`296`	`+ fn le(self, other: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {`
`293`	`297`	`if objtype::isinstance(&other, &vm.ctx.list_type()) {`
`294`	`298`	`let zelf = self.elements.borrow();`
`295`	`299`	`let other = get_elements(&other);`
`296`		`- Ok(seq_le(vm, &zelf, &other)?)`
	`300`	`+ let res = seq_le(vm, &zelf, &other)?;`
	`301`	`+ Ok(vm.new_bool(res))`
`297`	`302`	`} else {`
`298`		`- Err(vm.new_type_error(format!("Cannot compare {} and {} using '<='", self, other)))`
	`303`	`+ Ok(vm.ctx.not_implemented())`
`299`	`304`	`}`
`300`	`305`	`}`
`301`	`306`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+use std::fmt;`
`1`	`2`	`use std::hash::{Hash, Hasher};`
`2`	`3`	`use std::ops::Range;`
`3`	`4`	`use std::str::FromStr;`
`@@ -26,11 +27,9 @@ pub struct PyString {`
`26`	`27`	`}`
`27`	`28`	`pub type PyStringRef = PyRef<PyString>;`
`28`	`29`
`29`		`-impl<T: ToString> From<T> for PyString {`
`30`		`- fn from(t: T) -> PyString {`
`31`		`- PyString {`
`32`		`- value: t.to_string(),`
`33`		`- }`
	`30`	`+impl fmt::Display for PyString {`
	`31`	`+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
	`32`	`+ fmt::Display::fmt(&self.value, f)`
`34`	`33`	`}`
`35`	`34`	`}`
`36`	`35`
Original file line number	Diff line number	Diff line change
`@@ -768,9 +768,13 @@ impl<T> IntoPyObject for PyRef<T> {`
`768`	`768`	`}`
`769`	`769`	`}`
`770`	`770`
`771`		`-impl<T> fmt::Display for PyRef<T> {`
	`771`	`+impl<T: fmt::Display> fmt::Display for PyRef<T>`
	`772`	`+where`
	`773`	`+ T: PyValue + fmt::Display,`
	`774`	`+{`
`772`	`775`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`773`		`- self.obj.fmt(f)`
	`776`	`+ let value: &T = self.obj.payload().expect("unexpected payload for type");`
	`777`	`+ fmt::Display::fmt(value, f)`
`774`	`778`	`}`
`775`	`779`	`}`
`776`	`780`