PyTupleTyped as alias of PyTuple

Author: youknowone

vm/src/builtins/function.rs

@@ -8,7 +8,6 @@ use super::{
 #[cfg(feature = "jit")]
 use crate::common::lock::OnceCell;
 use crate::common::lock::PyMutex;
-use crate::convert::{ToPyObject, TryFromObject};
 use crate::function::ArgMapping;
 use crate::object::{Traverse, TraverseFn};
 use crate::{
@@ -32,7 +31,7 @@ pub struct PyFunction {
     code: PyRef<PyCode>,
     globals: PyDictRef,
     builtins: PyObjectRef,
-    closure: Option<PyTupleTyped<PyCellRef>>,
+    closure: Option<PyRef<PyTupleTyped<PyCellRef>>>,
     defaults_and_kwdefaults: PyMutex<(Option<PyTupleRef>, Option<PyDictRef>)>,
     name: PyMutex<PyStrRef>,
     qualname: PyMutex<PyStrRef>,
@@ -47,7 +46,9 @@ pub struct PyFunction {
 unsafe impl Traverse for PyFunction {
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
         self.globals.traverse(tracer_fn);
-        self.closure.traverse(tracer_fn);
+        if let Some(closure) = self.closure.as_ref() {
+            closure.as_untyped().traverse(tracer_fn);
+        }
         self.defaults_and_kwdefaults.traverse(tracer_fn);
     }
 }
@@ -58,7 +59,7 @@ impl PyFunction {
     pub(crate) fn new(
         code: PyRef<PyCode>,
         globals: PyDictRef,
-        closure: Option<PyTupleTyped<PyCellRef>>,
+        closure: Option<PyRef<PyTupleTyped<PyCellRef>>>,
         defaults: Option<PyTupleRef>,
         kw_only_defaults: Option<PyDictRef>,
         qualname: PyStrRef,
@@ -326,6 +327,7 @@ impl Py<PyFunction> {
     ) -> PyResult {
         #[cfg(feature = "jit")]
         if let Some(jitted_code) = self.jitted_code.get() {
+            use crate::convert::ToPyObject;
             match jit::get_jit_args(self, &func_args, jitted_code, vm) {
                 Ok(args) => {
                     return Ok(args.invoke().to_pyobject(vm));
@@ -427,7 +429,7 @@ impl PyFunction {
     #[pymember]
     fn __closure__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
         let zelf = Self::_as_pyref(&zelf, vm)?;
-        Ok(vm.unwrap_or_none(zelf.closure.clone().map(|x| x.to_pyobject(vm))))
+        Ok(vm.unwrap_or_none(zelf.closure.clone().map(|x| x.into())))
     }
 
     #[pymember]
@@ -612,8 +614,7 @@ impl Constructor for PyFunction {
             }
 
             // Validate that all items are cells and create typed tuple
-            let typed_closure =
-                PyTupleTyped::<PyCellRef>::try_from_object(vm, closure_tuple.into())?;
+            let typed_closure = closure_tuple.try_into_typed::<PyCell>(vm)?;
             Some(typed_closure)
         } else if !args.code.freevars.is_empty() {
             return Err(vm.new_type_error("arg 5 (closure) must be tuple"));

vm/src/builtins/tuple.rs

@@ -3,7 +3,7 @@ use crate::common::{
     hash::{PyHash, PyUHash},
     lock::PyMutex,
 };
-use crate::object::{Traverse, TraverseFn};
+use crate::object::{MaybeTraverse, Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     atomic_func,
@@ -449,6 +449,24 @@ impl Representable for PyTuple {
     }
 }
 
+impl PyRef<PyTuple> {
+    pub fn try_into_typed<T: PyPayload>(
+        self,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<PyTupleTyped<PyRef<T>>>> {
+        PyRef::<PyTupleTyped<PyRef<T>>>::try_from_untyped(self, vm)
+    }
+    /// # Safety
+    ///
+    /// The caller must ensure that all elements in the tuple are valid instances
+    /// of type `T` before calling this method. This is typically verified by
+    /// calling `try_into_typed` first.
+    unsafe fn into_typed_unchecked<T: PyPayload>(self) -> PyRef<PyTupleTyped<PyRef<T>>> {
+        let obj: PyObjectRef = self.into();
+        unsafe { obj.downcast_unchecked::<PyTupleTyped<PyRef<T>>>() }
+    }
+}
+
 #[pyclass(module = false, name = "tuple_iterator", traverse)]
 #[derive(Debug)]
 pub(crate) struct PyTupleIterator {
@@ -500,53 +518,75 @@ pub(crate) fn init(context: &Context) {
     PyTupleIterator::extend_class(context, context.types.tuple_iterator_type);
 }
 
-pub struct PyTupleTyped<T: TransmuteFromObject> {
+#[repr(transparent)]
+pub struct PyTupleTyped<R> {
     // SAFETY INVARIANT: T must be repr(transparent) over PyObjectRef, and the
     //                   elements must be logically valid when transmuted to T
-    tuple: PyTupleRef,
-    _marker: PhantomData<Vec<T>>,
+    tuple: PyTuple,
+    _marker: PhantomData<R>,
 }
 
-unsafe impl<T> Traverse for PyTupleTyped<T>
+unsafe impl<R> Traverse for PyTupleTyped<R>
 where
-    T: TransmuteFromObject + Traverse,
+    R: TransmuteFromObject,
 {
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
         self.tuple.traverse(tracer_fn);
     }
 }
 
-impl<T: TransmuteFromObject> TryFromObject for PyTupleTyped<T> {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let tuple = PyTupleRef::try_from_object(vm, obj)?;
-        for elem in &*tuple {
-            T::check(vm, elem)?
-        }
-        // SAFETY: the contract of TransmuteFromObject upholds the variant on `tuple`
-        Ok(Self {
-            tuple,
-            _marker: PhantomData,
-        })
+impl<R: TransmuteFromObject + Traverse> MaybeTraverse for PyTupleTyped<R> {
+    const IS_TRACE: bool = true;
+    fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.traverse(tracer_fn);
     }
 }
 
-impl<T: TransmuteFromObject> AsRef<[T]> for PyTupleTyped<T> {
-    fn as_ref(&self) -> &[T] {
-        self.as_slice()
+impl<T: PyPayload> PyTupleTyped<PyRef<T>> {
+    pub fn new_ref(elements: Vec<PyRef<T>>, ctx: &Context) -> PyRef<Self> {
+        // SAFETY: PyRef<T> has the same layout as PyObjectRef
+        unsafe {
+            let elements: Vec<PyObjectRef> =
+                std::mem::transmute::<Vec<PyRef<T>>, Vec<PyObjectRef>>(elements);
+            let tuple = PyTuple::new_ref(elements, ctx);
+            tuple.into_typed_unchecked::<T>()
+        }
     }
 }
 
-impl<T: TransmuteFromObject> PyTupleTyped<T> {
-    pub fn empty(vm: &VirtualMachine) -> Self {
-        Self {
-            tuple: vm.ctx.empty_tuple.clone(),
-            _marker: PhantomData,
+impl<T: PyPayload> PyRef<PyTupleTyped<PyRef<T>>> {
+    pub fn into_untyped(self) -> PyRef<PyTuple> {
+        // SAFETY: PyTupleTyped is transparent over PyTuple
+        unsafe { std::mem::transmute::<PyRef<PyTupleTyped<PyRef<T>>>, PyRef<PyTuple>>(self) }
+    }
+
+    pub fn try_from_untyped(tuple: PyTupleRef, vm: &VirtualMachine) -> PyResult<Self> {
+        // Check that all elements are of the correct type
+        for elem in tuple.as_slice() {
+            <PyRef<T> as TransmuteFromObject>::check(vm, elem)?;
         }
+        // SAFETY: We just verified all elements are of type T, and PyTupleTyped has the same layout as PyTuple
+        Ok(unsafe { std::mem::transmute::<PyRef<PyTuple>, PyRef<PyTupleTyped<PyRef<T>>>>(tuple) })
     }
+}
 
+impl<T: PyPayload> Py<PyTupleTyped<PyRef<T>>> {
+    pub fn as_untyped(&self) -> &Py<PyTuple> {
+        // SAFETY: PyTupleTyped is transparent over PyTuple
+        unsafe { std::mem::transmute::<&Py<PyTupleTyped<PyRef<T>>>, &Py<PyTuple>>(self) }
+    }
+}
+
+impl<T: PyPayload> AsRef<[PyRef<T>]> for PyTupleTyped<PyRef<T>> {
+    fn as_ref(&self) -> &[PyRef<T>] {
+        self.as_slice()
+    }
+}
+
+impl<T: PyPayload> PyTupleTyped<PyRef<T>> {
     #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        unsafe { &*(self.tuple.as_slice() as *const [PyObjectRef] as *const [T]) }
+    pub fn as_slice(&self) -> &[PyRef<T>] {
+        unsafe { &*(self.tuple.as_slice() as *const [PyObjectRef] as *const [PyRef<T>]) }
     }
 
     #[inline]
@@ -560,32 +600,16 @@ impl<T: TransmuteFromObject> PyTupleTyped<T> {
     }
 }
 
-impl<T: TransmuteFromObject> Clone for PyTupleTyped<T> {
-    fn clone(&self) -> Self {
-        Self {
-            tuple: self.tuple.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T: TransmuteFromObject + fmt::Debug> fmt::Debug for PyTupleTyped<T> {
+impl<R: fmt::Debug> fmt::Debug for PyTupleTyped<R> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_slice().fmt(f)
-    }
-}
-
-impl<T: TransmuteFromObject> From<PyTupleTyped<T>> for PyTupleRef {
-    #[inline]
-    fn from(tup: PyTupleTyped<T>) -> Self {
-        tup.tuple
+        self.tuple.as_slice().fmt(f)
     }
 }
 
-impl<T: TransmuteFromObject> ToPyObject for PyTupleTyped<T> {
+impl<T: PyPayload> From<PyRef<PyTupleTyped<PyRef<T>>>> for PyTupleRef {
     #[inline]
-    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        self.tuple.into()
+    fn from(tup: PyRef<PyTupleTyped<PyRef<T>>>) -> Self {
+        tup.into_untyped()
     }
 }
 

vm/src/builtins/type.rs

@@ -62,7 +62,7 @@ unsafe impl crate::object::Traverse for PyType {
 pub struct HeapTypeExt {
     pub name: PyRwLock<PyStrRef>,
     pub qualname: PyRwLock<PyStrRef>,
-    pub slots: Option<PyTupleTyped<PyStrRef>>,
+    pub slots: Option<PyRef<PyTupleTyped<PyStrRef>>>,
     pub sequence_methods: PySequenceMethods,
     pub mapping_methods: PyMappingMethods,
 }
@@ -1041,24 +1041,24 @@ impl Constructor for PyType {
         // TODO: Flags is currently initialized with HAS_DICT. Should be
         // updated when __slots__ are supported (toggling the flag off if
         // a class has __slots__ defined).
-        let heaptype_slots: Option<PyTupleTyped<PyStrRef>> =
+        let heaptype_slots: Option<PyRef<PyTupleTyped<PyStrRef>>> =
             if let Some(x) = attributes.get(identifier!(vm, __slots__)) {
-                Some(if x.to_owned().class().is(vm.ctx.types.str_type) {
-                    PyTupleTyped::<PyStrRef>::try_from_object(
-                        vm,
-                        vec![x.to_owned()].into_pytuple(vm).into(),
-                    )?
+                let slots = if x.class().is(vm.ctx.types.str_type) {
+                    let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
+                    PyTupleTyped::new_ref(vec![x.to_owned()], &vm.ctx)
                 } else {
-                    let iter = x.to_owned().get_iter(vm)?;
+                    let iter = x.get_iter(vm)?;
                     let elements = {
                         let mut elements = Vec::new();
                         while let PyIterReturn::Return(element) = iter.next(vm)? {
                             elements.push(element);
                         }
                         elements
                     };
-                    PyTupleTyped::<PyStrRef>::try_from_object(vm, elements.into_pytuple(vm).into())?
-                })
+                    let tuple = elements.into_pytuple(vm);
+                    tuple.try_into_typed(vm)?
+                };
+                Some(slots)
             } else {
                 None
             };
@@ -1082,7 +1082,7 @@ impl Constructor for PyType {
             let heaptype_ext = HeapTypeExt {
                 name: PyRwLock::new(name),
                 qualname: PyRwLock::new(qualname),
-                slots: heaptype_slots.to_owned(),
+                slots: heaptype_slots.clone(),
                 sequence_methods: PySequenceMethods::default(),
                 mapping_methods: PyMappingMethods::default(),
             };

vm/src/convert/try_from.rs

@@ -78,12 +78,12 @@ where
     #[inline]
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         let class = T::class(&vm.ctx);
-        if obj.fast_isinstance(class) {
+        let result = if obj.fast_isinstance(class) {
             obj.downcast()
-                .map_err(|obj| vm.new_downcast_runtime_error(class, &obj))
         } else {
-            Err(vm.new_downcast_type_error(class, &obj))
-        }
+            Err(obj)
+        };
+        result.map_err(|obj| vm.new_downcast_type_error(class, &obj))
     }
 }
 

vm/src/frame.rs

@@ -7,7 +7,7 @@ use crate::{
         PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyType,
         asyncgenerator::PyAsyncGenWrappedValue,
         function::{PyCell, PyCellRef, PyFunction},
-        tuple::{PyTuple, PyTupleRef, PyTupleTyped},
+        tuple::{PyTuple, PyTupleRef},
     },
     bytecode,
     convert::{IntoObject, ToPyResult},
@@ -1346,11 +1346,14 @@ impl ExecutingFrame<'_> {
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn import(&mut self, vm: &VirtualMachine, module_name: Option<&Py<PyStr>>) -> PyResult<()> {
         let module_name = module_name.unwrap_or(vm.ctx.empty_str);
-        let from_list = <Option<PyTupleTyped<PyStrRef>>>::try_from_object(vm, self.pop_value())?
-            .unwrap_or_else(|| PyTupleTyped::empty(vm));
+        let top = self.pop_value();
+        let from_list = match <Option<PyTupleRef>>::try_from_object(vm, top)? {
+            Some(from_list) => from_list.try_into_typed::<PyStr>(vm)?,
+            None => vm.ctx.empty_tuple_typed().to_owned(),
+        };
         let level = usize::try_from_object(vm, self.pop_value())?;
 
-        let module = vm.import_from(module_name, from_list, level)?;
+        let module = vm.import_from(module_name, &from_list, level)?;
 
         self.push_value(module);
         Ok(())
@@ -1839,7 +1842,8 @@ impl ExecutingFrame<'_> {
             .expect("Second to top value on the stack must be a code object");
 
         let closure = if flags.contains(bytecode::MakeFunctionFlags::CLOSURE) {
-            Some(PyTupleTyped::try_from_object(vm, self.pop_value()).unwrap())
+            let tuple = PyTupleRef::try_from_object(vm, self.pop_value()).unwrap();
+            Some(tuple.try_into_typed(vm).expect("This is a compiler bug"))
         } else {
             None
         };