Merge pull request RustPython#679 from RustPython/joey/vm-not-pycontext

windelbouwman · web-flow · commit 7a4d653268f4 · 2019-03-15T19:23:39.000+01:00
Make it possible to implement PyValue in stdlib
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -184,8 +184,8 @@ pub struct Frame {
 }
 
 impl PyValue for Frame {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.frame_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.frame_type()
     }
 }
 
diff --git a/vm/src/obj/objbool.rs b/vm/src/obj/objbool.rs
@@ -12,8 +12,8 @@ use super::objtuple::PyTuple;
 use super::objtype;
 
 impl IntoPyObject for bool {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-        Ok(ctx.new_bool(self))
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm.ctx.new_bool(self))
     }
 }
 
diff --git a/vm/src/obj/objbuiltinfunc.rs b/vm/src/obj/objbuiltinfunc.rs
@@ -1,15 +1,16 @@
 use std::fmt;
 
-use crate::pyobject::{PyContext, PyNativeFunc, PyObjectRef, PyValue};
+use crate::pyobject::{PyNativeFunc, PyObjectRef, PyValue};
+use crate::vm::VirtualMachine;
 
 pub struct PyBuiltinFunction {
     // TODO: shouldn't be public
     pub value: PyNativeFunc,
 }
 
 impl PyValue for PyBuiltinFunction {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.builtin_function_or_method_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.builtin_function_or_method_type()
     }
 }
 
diff --git a/vm/src/obj/objbytearray.rs b/vm/src/obj/objbytearray.rs
@@ -29,8 +29,8 @@ impl PyByteArray {
 }
 
 impl PyValue for PyByteArray {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.bytearray_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.bytearray_type()
     }
 }
 
diff --git a/vm/src/obj/objbytes.rs b/vm/src/obj/objbytes.rs
@@ -30,8 +30,8 @@ impl Deref for PyBytes {
 }
 
 impl PyValue for PyBytes {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.bytes_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.bytes_type()
     }
 }
 
diff --git a/vm/src/obj/objcode.rs b/vm/src/obj/objcode.rs
@@ -26,8 +26,8 @@ impl fmt::Debug for PyCode {
 }
 
 impl PyValue for PyCode {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.code_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.code_type()
     }
 }
 
diff --git a/vm/src/obj/objcomplex.rs b/vm/src/obj/objcomplex.rs
@@ -14,8 +14,8 @@ pub struct PyComplex {
 }
 
 impl PyValue for PyComplex {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.complex_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.complex_type()
     }
 }
 
diff --git a/vm/src/obj/objdict.rs b/vm/src/obj/objdict.rs
@@ -30,8 +30,8 @@ impl fmt::Debug for PyDict {
 }
 
 impl PyValue for PyDict {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.dict_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.dict_type()
     }
 }
 
diff --git a/vm/src/obj/objenumerate.rs b/vm/src/obj/objenumerate.rs
@@ -17,8 +17,8 @@ pub struct PyEnumerate {
 }
 
 impl PyValue for PyEnumerate {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.enumerate_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.enumerate_type()
     }
 }
 
diff --git a/vm/src/obj/objfilter.rs b/vm/src/obj/objfilter.rs
@@ -13,8 +13,8 @@ pub struct PyFilter {
 }
 
 impl PyValue for PyFilter {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.filter_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.filter_type()
     }
 }
 
diff --git a/vm/src/obj/objfloat.rs b/vm/src/obj/objfloat.rs
@@ -16,14 +16,14 @@ pub struct PyFloat {
 }
 
 impl PyValue for PyFloat {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.float_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.float_type()
     }
 }
 
 impl IntoPyObject for f64 {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-        Ok(ctx.new_float(self))
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm.ctx.new_float(self))
     }
 }
 
diff --git a/vm/src/obj/objfunction.rs b/vm/src/obj/objfunction.rs
@@ -23,8 +23,8 @@ impl PyFunction {
 }
 
 impl PyValue for PyFunction {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.function_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.function_type()
     }
 }
 
@@ -42,8 +42,8 @@ impl PyMethod {
 }
 
 impl PyValue for PyMethod {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.bound_method_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.bound_method_type()
     }
 }
 
diff --git a/vm/src/obj/objgenerator.rs b/vm/src/obj/objgenerator.rs
@@ -14,8 +14,8 @@ pub struct PyGenerator {
 }
 
 impl PyValue for PyGenerator {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.generator_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.generator_type()
     }
 }
 
diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -30,22 +30,22 @@ impl PyInt {
 }
 
 impl IntoPyObject for BigInt {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-        Ok(ctx.new_int(self))
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm.ctx.new_int(self))
     }
 }
 
 impl PyValue for PyInt {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.int_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.int_type()
     }
 }
 
 macro_rules! impl_into_pyobject_int {
     ($($t:ty)*) => {$(
         impl IntoPyObject for $t {
-            fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-                Ok(ctx.new_int(self))
+            fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+                Ok(vm.ctx.new_int(self))
             }
         }
     )*};
diff --git a/vm/src/obj/objlist.rs b/vm/src/obj/objlist.rs
@@ -38,8 +38,8 @@ impl From<Vec<PyObjectRef>> for PyList {
 }
 
 impl PyValue for PyList {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.list_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.list_type()
     }
 }
 
diff --git a/vm/src/obj/objmap.rs b/vm/src/obj/objmap.rs
@@ -12,8 +12,8 @@ pub struct PyMap {
 }
 
 impl PyValue for PyMap {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.map_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.map_type()
     }
 }
 
diff --git a/vm/src/obj/objmemory.rs b/vm/src/obj/objmemory.rs
@@ -9,8 +9,8 @@ pub struct PyMemoryView {
 }
 
 impl PyValue for PyMemoryView {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.memoryview_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.memoryview_type()
     }
 }
 
diff --git a/vm/src/obj/objmodule.rs b/vm/src/obj/objmodule.rs
@@ -9,8 +9,8 @@ pub struct PyModule {
 pub type PyModuleRef = PyRef<PyModule>;
 
 impl PyValue for PyModule {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.module_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.module_type()
     }
 }
 
diff --git a/vm/src/obj/objnone.rs b/vm/src/obj/objnone.rs
@@ -8,24 +8,24 @@ pub struct PyNone;
 pub type PyNoneRef = PyRef<PyNone>;
 
 impl PyValue for PyNone {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.none().typ()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.none().typ()
     }
 }
 
 // This allows a built-in function to not return a value, mapping to
 // Python's behavior of returning `None` in this situation.
 impl IntoPyObject for () {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-        Ok(ctx.none())
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm.ctx.none())
     }
 }
 
 impl<T: IntoPyObject> IntoPyObject for Option<T> {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
         match self {
-            Some(x) => x.into_pyobject(ctx),
-            None => Ok(ctx.none()),
+            Some(x) => x.into_pyobject(vm),
+            None => Ok(vm.ctx.none()),
         }
     }
 }
diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -12,8 +12,8 @@ use crate::vm::VirtualMachine;
 pub struct PyInstance;
 
 impl PyValue for PyInstance {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.object()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.object()
     }
 }
 
diff --git a/vm/src/obj/objproperty.rs b/vm/src/obj/objproperty.rs
@@ -16,8 +16,8 @@ pub struct PyReadOnlyProperty {
 }
 
 impl PyValue for PyReadOnlyProperty {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.readonly_property_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.readonly_property_type()
     }
 }
 
@@ -38,8 +38,8 @@ pub struct PyProperty {
 }
 
 impl PyValue for PyProperty {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.property_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.property_type()
     }
 }
 
diff --git a/vm/src/obj/objrange.rs b/vm/src/obj/objrange.rs
@@ -24,8 +24,8 @@ pub struct PyRange {
 }
 
 impl PyValue for PyRange {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.range_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.range_type()
     }
 }
 
diff --git a/vm/src/obj/objset.rs b/vm/src/obj/objset.rs
@@ -30,8 +30,8 @@ impl fmt::Debug for PySet {
 }
 
 impl PyValue for PySet {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.set_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.set_type()
     }
 }
 
diff --git a/vm/src/obj/objslice.rs b/vm/src/obj/objslice.rs
@@ -14,8 +14,8 @@ pub struct PySlice {
 }
 
 impl PyValue for PySlice {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.slice_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.slice_type()
     }
 }
 
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -597,14 +597,14 @@ impl PyStringRef {
 }
 
 impl PyValue for PyString {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.str_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.str_type()
     }
 }
 
 impl IntoPyObject for String {
-    fn into_pyobject(self, ctx: &PyContext) -> PyResult {
-        Ok(ctx.new_str(self))
+    fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {
+        Ok(vm.ctx.new_str(self))
     }
 }
 
diff --git a/vm/src/obj/objtuple.rs b/vm/src/obj/objtuple.rs
@@ -39,8 +39,8 @@ impl From<Vec<PyObjectRef>> for PyTuple {
 }
 
 impl PyValue for PyTuple {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.tuple_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.tuple_type()
     }
 }
 
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -22,8 +22,8 @@ pub struct PyClass {
 pub type PyClassRef = PyRef<PyClass>;
 
 impl PyValue for PyClass {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.type_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.type_type()
     }
 }
 
diff --git a/vm/src/obj/objweakref.rs b/vm/src/obj/objweakref.rs
@@ -23,8 +23,8 @@ impl PyWeak {
 }
 
 impl PyValue for PyWeak {
-    fn required_type(ctx: &PyContext) -> PyObjectRef {
-        ctx.weakref_type()
+    fn class(vm: &mut VirtualMachine) -> PyObjectRef {
+        vm.ctx.weakref_type()
     }
 }
 
diff --git a/vm/src/obj/objzip.rs b/vm/src/obj/objzip.rs
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
diff --git a/vm/src/stdlib/re.rs b/vm/src/stdlib/re.rs
diff --git a/vm/src/stdlib/socket.rs b/vm/src/stdlib/socket.rs
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
diff --git a/wasm/lib/src/browser_module.rs b/wasm/lib/src/browser_module.rs

Original file line number	Diff line number	Diff line change
`@@ -184,8 +184,8 @@ pub struct Frame {`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`impl PyValue for Frame {`
`187`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`188`		`- ctx.frame_type()`
	`187`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`188`	`+ vm.ctx.frame_type()`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ use super::objtuple::PyTuple;`
`12`	`12`	`use super::objtype;`
`13`	`13`
`14`	`14`	`impl IntoPyObject for bool {`
`15`		`- fn into_pyobject(self, ctx: &PyContext) -> PyResult {`
`16`		`- Ok(ctx.new_bool(self))`
	`15`	`+ fn into_pyobject(self, vm: &mut VirtualMachine) -> PyResult {`
	`16`	`+ Ok(vm.ctx.new_bool(self))`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,16 @@`
`1`	`1`	`use std::fmt;`
`2`	`2`
`3`		`-use crate::pyobject::{PyContext, PyNativeFunc, PyObjectRef, PyValue};`
	`3`	`+use crate::pyobject::{PyNativeFunc, PyObjectRef, PyValue};`
	`4`	`+use crate::vm::VirtualMachine;`
`4`	`5`
`5`	`6`	`pub struct PyBuiltinFunction {`
`6`	`7`	`// TODO: shouldn't be public`
`7`	`8`	`pub value: PyNativeFunc,`
`8`	`9`	`}`
`9`	`10`
`10`	`11`	`impl PyValue for PyBuiltinFunction {`
`11`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`12`		`- ctx.builtin_function_or_method_type()`
	`12`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`13`	`+ vm.ctx.builtin_function_or_method_type()`
`13`	`14`	`}`
`14`	`15`	`}`
`15`	`16`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,8 @@ impl PyByteArray {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`impl PyValue for PyByteArray {`
`32`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`33`		`- ctx.bytearray_type()`
	`32`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`33`	`+ vm.ctx.bytearray_type()`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ impl Deref for PyBytes {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`impl PyValue for PyBytes {`
`33`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`34`		`- ctx.bytes_type()`
	`33`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`34`	`+ vm.ctx.bytes_type()`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ impl fmt::Debug for PyCode {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`impl PyValue for PyCode {`
`29`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`30`		`- ctx.code_type()`
	`29`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`30`	`+ vm.ctx.code_type()`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ pub struct PyComplex {`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`impl PyValue for PyComplex {`
`17`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`18`		`- ctx.complex_type()`
	`17`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`18`	`+ vm.ctx.complex_type()`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ impl fmt::Debug for PyDict {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`impl PyValue for PyDict {`
`33`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`34`		`- ctx.dict_type()`
	`33`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`34`	`+ vm.ctx.dict_type()`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ pub struct PyEnumerate {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`impl PyValue for PyEnumerate {`
`20`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`21`		`- ctx.enumerate_type()`
	`20`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`21`	`+ vm.ctx.enumerate_type()`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ pub struct PyFilter {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`impl PyValue for PyFilter {`
`16`		`- fn required_type(ctx: &PyContext) -> PyObjectRef {`
`17`		`- ctx.filter_type()`
	`16`	`+ fn class(vm: &mut VirtualMachine) -> PyObjectRef {`
	`17`	`+ vm.ctx.filter_type()`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`