Make PyObject.typ a PyClassRef

Author: skinnyBat

src/main.rs

@@ -65,16 +65,11 @@ fn main() {
 }
 
 fn _run_string(vm: &VirtualMachine, source: &str, source_path: String) -> PyResult {
-    let code_obj = compile::compile(
-        source,
-        &compile::Mode::Exec,
-        source_path,
-        vm.ctx.code_type(),
-    )
-    .map_err(|err| {
-        let syntax_error = vm.context().exceptions.syntax_error.clone();
-        vm.new_exception(syntax_error, err.to_string())
-    })?;
+    let code_obj =
+        compile::compile(vm, source, &compile::Mode::Exec, source_path).map_err(|err| {
+            let syntax_error = vm.context().exceptions.syntax_error.clone();
+            vm.new_exception(syntax_error, err.to_string())
+        })?;
     // trace!("Code object: {:?}", code_obj.borrow());
     let vars = vm.ctx.new_scope(); // Keep track of local variables
     vm.run_code_obj(code_obj, vars)
@@ -115,12 +110,7 @@ fn run_script(vm: &VirtualMachine, script_file: &str) -> PyResult {
 }
 
 fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> Result<(), CompileError> {
-    match compile::compile(
-        source,
-        &compile::Mode::Single,
-        "<stdin>".to_string(),
-        vm.ctx.code_type(),
-    ) {
+    match compile::compile(vm, source, &compile::Mode::Single, "<stdin>".to_string()) {
         Ok(code) => {
             if let Err(err) = vm.run_code_obj(code, scope) {
                 print_exception(vm, &err);

vm/src/builtins.rs

@@ -24,6 +24,7 @@ use crate::pyobject::{
 };
 use crate::vm::VirtualMachine;
 
+use crate::obj::objcode::PyCodeRef;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::stdlib::io::io_open;
 
@@ -112,22 +113,17 @@ fn builtin_chr(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.new_str(txt))
 }
 
-fn builtin_compile(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [
-            (source, None),
-            (filename, Some(vm.ctx.str_type())),
-            (mode, Some(vm.ctx.str_type()))
-        ]
-    );
-    let source = objstr::get_value(source);
+fn builtin_compile(
+    source: PyStringRef,
+    filename: PyStringRef,
+    mode: PyStringRef,
+    vm: &VirtualMachine,
+) -> PyResult<PyCodeRef> {
     // TODO: fix this newline bug:
-    let source = format!("{}\n", source);
+    let source = format!("{}\n", &source.value);
 
     let mode = {
-        let mode = objstr::get_value(mode);
+        let mode = &mode.value;
         if mode == "exec" {
             compile::Mode::Exec
         } else if mode == "eval" {
@@ -141,9 +137,7 @@ fn builtin_compile(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         }
     };
 
-    let filename = objstr::get_value(filename);
-
-    compile::compile(&source, &mode, filename, vm.ctx.code_type()).map_err(|err| {
+    compile::compile(vm, &source, &mode, filename.value.to_string()).map_err(|err| {
         let syntax_error = vm.context().exceptions.syntax_error.clone();
         vm.new_exception(syntax_error, err.to_string())
     })
@@ -190,25 +184,23 @@ fn builtin_eval(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     let scope = make_scope(vm, globals, locals)?;
 
     // Determine code object:
-    let code_obj = if objtype::isinstance(source, &vm.ctx.code_type()) {
-        source.clone()
+    let code_obj = if let Ok(code_obj) = PyCodeRef::try_from_object(vm, source.clone()) {
+        code_obj
     } else if objtype::isinstance(source, &vm.ctx.str_type()) {
         let mode = compile::Mode::Eval;
         let source = objstr::get_value(source);
         // TODO: fix this newline bug:
         let source = format!("{}\n", source);
-        compile::compile(&source, &mode, "<string>".to_string(), vm.ctx.code_type()).map_err(
-            |err| {
-                let syntax_error = vm.context().exceptions.syntax_error.clone();
-                vm.new_exception(syntax_error, err.to_string())
-            },
-        )?
+        compile::compile(vm, &source, &mode, "<string>".to_string()).map_err(|err| {
+            let syntax_error = vm.context().exceptions.syntax_error.clone();
+            vm.new_exception(syntax_error, err.to_string())
+        })?
     } else {
         return Err(vm.new_type_error("code argument must be str or code object".to_string()));
     };
 
     // Run the source:
-    vm.run_code_obj(code_obj.clone(), scope)
+    vm.run_code_obj(code_obj, scope)
 }
 
 /// Implements `exec`
@@ -229,14 +221,12 @@ fn builtin_exec(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         let source = objstr::get_value(source);
         // TODO: fix this newline bug:
         let source = format!("{}\n", source);
-        compile::compile(&source, &mode, "<string>".to_string(), vm.ctx.code_type()).map_err(
-            |err| {
-                let syntax_error = vm.context().exceptions.syntax_error.clone();
-                vm.new_exception(syntax_error, err.to_string())
-            },
-        )?
-    } else if objtype::isinstance(source, &vm.ctx.code_type()) {
-        source.clone()
+        compile::compile(vm, &source, &mode, "<string>".to_string()).map_err(|err| {
+            let syntax_error = vm.context().exceptions.syntax_error.clone();
+            vm.new_exception(syntax_error, err.to_string())
+        })?
+    } else if let Ok(code_obj) = PyCodeRef::try_from_object(vm, source.clone()) {
+        code_obj
     } else {
         return Err(vm.new_type_error("source argument must be str or code object".to_string()));
     };

vm/src/compile.rs

@@ -8,8 +8,9 @@
 use crate::bytecode::{self, CallType, CodeObject, Instruction, Varargs};
 use crate::error::CompileError;
 use crate::obj::objcode;
-use crate::obj::objtype::PyClassRef;
-use crate::pyobject::{PyObject, PyObjectRef};
+use crate::obj::objcode::PyCodeRef;
+use crate::pyobject::PyValue;
+use crate::VirtualMachine;
 use num_complex::Complex64;
 use rustpython_parser::{ast, parser};
 
@@ -24,11 +25,11 @@ struct Compiler {
 
 /// Compile a given sourcecode into a bytecode object.
 pub fn compile(
+    vm: &VirtualMachine,
     source: &str,
     mode: &Mode,
     source_path: String,
-    code_type: PyClassRef,
-) -> Result<PyObjectRef, CompileError> {
+) -> Result<PyCodeRef, CompileError> {
     let mut compiler = Compiler::new();
     compiler.source_path = Some(source_path);
     compiler.push_new_code_object("<module>".to_string());
@@ -50,10 +51,7 @@ pub fn compile(
 
     let code = compiler.pop_code_object();
     trace!("Compilation completed: {:?}", code);
-    Ok(PyObject::new(
-        objcode::PyCode::new(code),
-        code_type.into_object(),
-    ))
+    Ok(objcode::PyCode::new(code).into_ref(vm))
 }
 
 pub enum Mode {

vm/src/eval.rs

@@ -8,12 +8,7 @@ use crate::pyobject::PyResult;
 use crate::vm::VirtualMachine;
 
 pub fn eval(vm: &VirtualMachine, source: &str, scope: Scope, source_path: &str) -> PyResult {
-    match compile::compile(
-        source,
-        &compile::Mode::Eval,
-        source_path.to_string(),
-        vm.ctx.code_type(),
-    ) {
+    match compile::compile(vm, source, &compile::Mode::Eval, source_path.to_string()) {
         Ok(bytecode) => {
             debug!("Code object: {:?}", bytecode);
             vm.run_code_obj(bytecode, scope)

vm/src/function.rs

@@ -305,6 +305,13 @@ pub enum OptionalArg<T> {
 }
 
 impl<T> OptionalArg<T> {
+    pub fn is_present(&self) -> bool {
+        match self {
+            Present(_) => true,
+            Missing => false,
+        }
+    }
+
     pub fn into_option(self) -> Option<T> {
         match self {
             Present(value) => Some(value),

vm/src/import.rs

@@ -27,10 +27,10 @@ fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &s
     let source = util::read_file(file_path.as_path())
         .map_err(|e| vm.new_exception(import_error.clone(), e.description().to_string()))?;
     let code_obj = compile::compile(
+        vm,
         &source,
         &compile::Mode::Exec,
         file_path.to_str().unwrap().to_string(),
-        vm.ctx.code_type(),
     )
     .map_err(|err| {
         let syntax_error = vm.context().exceptions.syntax_error.clone();

vm/src/obj/objcode.rs

@@ -7,9 +7,11 @@ use std::fmt;
 use crate::bytecode;
 use crate::function::PyFuncArgs;
 use crate::obj::objtype::PyClassRef;
-use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyResult, PyValue, TypeProtocol};
+use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
 use crate::vm::VirtualMachine;
 
+pub type PyCodeRef = PyRef<PyCode>;
+
 pub struct PyCode {
     code: bytecode::CodeObject,
 }

vm/src/obj/objfilter.rs

@@ -1,13 +1,13 @@
 use crate::function::PyFuncArgs;
-use crate::pyobject::{
-    IdProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
-};
+use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
 use crate::vm::VirtualMachine; // Required for arg_check! to use isinstance
 
 use super::objbool;
 use super::objiter;
 use crate::obj::objtype::PyClassRef;
 
+pub type PyFilterRef = PyRef<PyFilter>;
+
 #[derive(Debug)]
 pub struct PyFilter {
     predicate: PyObjectRef,
@@ -20,20 +20,19 @@ impl PyValue for PyFilter {
     }
 }
 
-fn filter_new(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(cls, None), (function, None), (iterable, None)]
-    );
-    let iterator = objiter::get_iter(vm, iterable)?;
-    Ok(PyObject::new(
-        PyFilter {
-            predicate: function.clone(),
-            iterator,
-        },
-        cls.clone(),
-    ))
+fn filter_new(
+    cls: PyClassRef,
+    function: PyObjectRef,
+    iterable: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<PyFilterRef> {
+    let iterator = objiter::get_iter(vm, &iterable)?;
+
+    PyFilter {
+        predicate: function.clone(),
+        iterator,
+    }
+    .into_ref_with_type(vm, cls)
 }
 
 fn filter_next(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objfloat.rs

@@ -4,7 +4,7 @@ use super::objstr;
 use super::objtype;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
-    IntoPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_bigint::ToBigInt;
@@ -155,7 +155,7 @@ impl PyFloatRef {
         }
     }
 
-    fn new_float(cls: PyObjectRef, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    fn new_float(cls: PyClassRef, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyFloatRef> {
         let value = if objtype::isinstance(&arg, &vm.ctx.float_type()) {
             get_value(&arg)
         } else if objtype::isinstance(&arg, &vm.ctx.int_type()) {
@@ -193,7 +193,7 @@ impl PyFloatRef {
             let type_name = objtype::get_type_name(&arg.typ());
             return Err(vm.new_type_error(format!("can't convert {} to float", type_name)));
         };
-        Ok(PyObject::new(PyFloat { value }, cls.clone()))
+        PyFloat { value }.into_ref_with_type(vm, cls)
     }
 
     fn mod_(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {

vm/src/obj/objmemory.rs

@@ -1,8 +1,9 @@
-use crate::function::PyFuncArgs;
 use crate::obj::objtype::PyClassRef;
-use crate::pyobject::{PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol};
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
+pub type PyMemoryViewRef = PyRef<PyMemoryView>;
+
 #[derive(Debug)]
 pub struct PyMemoryView {
     obj: PyObjectRef,
@@ -14,15 +15,13 @@ impl PyValue for PyMemoryView {
     }
 }
 
-pub fn new_memory_view(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(vm, args, required = [(cls, None), (bytes_object, None)]);
-    vm.ctx.set_attr(cls, "obj", bytes_object.clone());
-    Ok(PyObject::new(
-        PyMemoryView {
-            obj: bytes_object.clone(),
-        },
-        cls.clone(),
-    ))
+pub fn new_memory_view(
+    cls: PyClassRef,
+    bytes_object: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<PyMemoryViewRef> {
+    vm.ctx.set_attr(&cls, "obj", bytes_object.clone());
+    PyMemoryView { obj: bytes_object }.into_ref_with_type(vm, cls)
 }
 
 pub fn init(ctx: &PyContext) {

vm/src/obj/objobject.rs

@@ -7,7 +7,7 @@ use crate::obj::objproperty::PropertyBuilder;
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{
     DictProtocol, IdProtocol, PyAttributes, PyContext, PyObject, PyObjectRef, PyResult, PyValue,
-    TypeProtocol,
+    TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -22,7 +22,7 @@ impl PyValue for PyInstance {
 
 pub fn new_instance(vm: &VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     // more or less __new__ operator
-    let cls = args.shift();
+    let cls = PyClassRef::try_from_object(vm, args.shift())?;
     Ok(if cls.is(&vm.ctx.object) {
         PyObject::new_without_dict(PyInstance, cls)
     } else {

vm/src/obj/objproperty.rs

@@ -200,15 +200,15 @@ impl<'a> PropertyBuilder<'a> {
                 deleter: None,
             };
 
-            PyObject::new(payload, self.ctx.property_type().into_object())
+            PyObject::new(payload, self.ctx.property_type())
         } else {
             let payload = PyReadOnlyProperty {
                 getter: self.getter.expect(
                     "One of add_getter/add_setter must be called when constructing a property",
                 ),
             };
 
-            PyObject::new(payload, self.ctx.readonly_property_type().into_object())
+            PyObject::new(payload, self.ctx.readonly_property_type())
         }
     }
 }

vm/src/obj/objsequence.rs

@@ -163,12 +163,12 @@ pub fn get_item(
         if sequence.payload::<PyList>().is_some() {
             Ok(PyObject::new(
                 PyList::from(elements.to_vec().get_slice_items(vm, &subscript)?),
-                sequence.typ(),
+                sequence.type_pyref(),
             ))
         } else if sequence.payload::<PyTuple>().is_some() {
             Ok(PyObject::new(
                 PyTuple::from(elements.to_vec().get_slice_items(vm, &subscript)?),
-                sequence.typ(),
+                sequence.type_pyref(),
             ))
         } else {
             panic!("sequence get_item called for non-sequence")