Add PyValuePayload trait and use it for PyObject.payload

coolreader18 · coolreader18 · commit e49d7146a0fa · 2019-03-12T18:31:59.000-05:00
diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -4,7 +4,7 @@ use super::objtype;
 use crate::obj::objproperty::PropertyBuilder;
 use crate::pyobject::{
     AttributeProtocol, DictProtocol, IdProtocol, PyAttributes, PyContext, PyFuncArgs, PyObject,
-    PyObjectRef, PyRef, PyResult, TypeProtocol,
+    PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use std::cell::RefCell;
@@ -13,6 +13,12 @@ use std::collections::HashMap;
 #[derive(Clone, Debug)]
 pub struct PyInstance;
 
+impl PyValue for PyInstance {
+    fn required_type(_ctx: &PyContext) -> PyObjectRef {
+        panic!("no specific type for PyInstance, don't type check me")
+    }
+}
+
 pub type PyInstanceRef = PyRef<PyInstance>;
 
 pub fn new_instance(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -591,11 +591,7 @@ impl PyContext {
     }
 
     pub fn new_instance(&self, class: PyObjectRef, dict: Option<PyAttributes>) -> PyObjectRef {
-        let dict = if let Some(dict) = dict {
-            dict
-        } else {
-            PyAttributes::new()
-        };
+        let dict = dict.unwrap_or_default();
         PyObject {
             typ: Some(class),
             dict: Some(RefCell::new(dict)),
@@ -665,7 +661,7 @@ impl Default for PyContext {
 pub struct PyObject {
     pub typ: Option<PyObjectRef>,
     pub dict: Option<RefCell<PyAttributes>>, // __dict__ member
-    pub payload: Box<dyn Any>,
+    pub payload: Box<dyn PyValuePayload>,
 }
 
 impl Default for PyObject {
@@ -1526,7 +1522,7 @@ impl PyValue for PyIteratorValue {
 }
 
 impl PyObject {
-    pub fn new<T: PyValue>(payload: T, typ: PyObjectRef) -> PyObjectRef {
+    pub fn new<T: PyValuePayload>(payload: T, typ: PyObjectRef) -> PyObjectRef {
         PyObject {
             typ: Some(typ),
             dict: Some(RefCell::new(PyAttributes::new())),
@@ -1541,16 +1537,31 @@ impl PyObject {
     }
 
     pub fn payload<T: PyValue>(&self) -> Option<&T> {
-        self.payload.downcast_ref()
+        let payload: &dyn Any = &self.payload;
+        payload.downcast_ref()
     }
 }
 
-// The intention is for this to replace `PyObjectPayload` once everything is
-// converted to use `PyObjectPayload::AnyRustvalue`.
-pub trait PyValue: Any + fmt::Debug {
+pub trait PyValue: fmt::Debug + 'static {
     fn required_type(ctx: &PyContext) -> PyObjectRef;
 }
 
+pub trait PyValuePayload: Any + fmt::Debug + 'static {
+    fn required_type(&self, ctx: &PyContext) -> PyObjectRef;
+}
+
+impl<T: PyValue + 'static> PyValuePayload for T {
+    fn required_type(&self, ctx: &PyContext) -> PyObjectRef {
+        T::required_type(ctx)
+    }
+}
+
+impl PyValuePayload for () {
+    fn required_type(&self, _ctx: &PyContext) -> PyObjectRef {
+        panic!("No specific python type for rust unit, don't type check")
+    }
+}
+
 impl FromPyObjectRef for PyRef<PyClass> {
     fn from_pyobj(obj: &PyObjectRef) -> Self {
         if let Some(_) = obj.payload::<PyClass>() {
diff --git a/vm/src/stdlib/re.rs b/vm/src/stdlib/re.rs
@@ -197,15 +197,15 @@ fn match_end(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 /// Retrieve inner rust regex from python object:
 fn get_regex<'a>(obj: &'a PyObjectRef) -> &'a Regex {
     // TODO: Regex shouldn't be stored in payload directly, create newtype wrapper
-    if let Some(regex) = obj.payload.downcast_ref::<Regex>() {
+    if let Some(regex) = obj.payload::<Regex>() {
         return regex;
     }
     panic!("Inner error getting regex {:?}", obj);
 }
 
 /// Retrieve inner rust match from python object:
 fn get_match<'a>(obj: &'a PyObjectRef) -> &'a PyMatch {
-    if let Some(value) = obj.payload.downcast_ref::<PyMatch>() {
+    if let Some(value) = obj.payload::<PyMatch>() {
         return value;
     }
     panic!("Inner error getting match {:?}", obj);

Original file line number	Diff line number	Diff line change
`@@ -197,15 +197,15 @@ fn match_end(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {`
`197`	`197`	`/// Retrieve inner rust regex from python object:`
`198`	`198`	`fn get_regex<'a>(obj: &'a PyObjectRef) -> &'a Regex {`
`199`	`199`	`// TODO: Regex shouldn't be stored in payload directly, create newtype wrapper`
`200`		`- if let Some(regex) = obj.payload.downcast_ref::<Regex>() {`
	`200`	`+ if let Some(regex) = obj.payload::<Regex>() {`
`201`	`201`	`return regex;`
`202`	`202`	`}`
`203`	`203`	`panic!("Inner error getting regex {:?}", obj);`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`/// Retrieve inner rust match from python object:`
`207`	`207`	`fn get_match<'a>(obj: &'a PyObjectRef) -> &'a PyMatch {`
`208`		`- if let Some(value) = obj.payload.downcast_ref::<PyMatch>() {`
	`208`	`+ if let Some(value) = obj.payload::<PyMatch>() {`
`209`	`209`	`return value;`
`210`	`210`	`}`
`211`	`211`	`panic!("Inner error getting match {:?}", obj);`