migrate TryIntoRef to IntoPyStrRef

Author: youknowone

vm/src/builtins/pystr.rs

@@ -16,7 +16,7 @@ use crate::{
     stdlib::sys,
     utils::Either,
     IdProtocol, ItemProtocol, PyClassDef, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef,
-    PyRef, PyResult, PyValue, TryIntoRef, TypeProtocol, VirtualMachine,
+    PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine,
 };
 use ascii::{AsciiStr, AsciiString};
 use bstr::ByteSlice;
@@ -169,23 +169,41 @@ impl fmt::Display for PyStr {
     }
 }
 
-impl TryIntoRef<PyStr> for AsciiString {
+pub trait IntoPyStrRef {
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyStrRef;
+}
+
+impl IntoPyStrRef for PyStrRef {
+    #[inline]
+    fn into_pystr_ref(self, _vm: &VirtualMachine) -> PyRef<PyStr> {
+        self
+    }
+}
+
+impl IntoPyStrRef for PyStr {
     #[inline]
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
-        unsafe { PyStr::new_ascii_unchecked(self.into()) }.into_ref(vm)
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+        self.into_ref(vm)
+    }
+}
+
+impl IntoPyStrRef for AsciiString {
+    #[inline]
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+        PyStr::from(self).into_ref(vm)
     }
 }
 
-impl TryIntoRef<PyStr> for String {
+impl IntoPyStrRef for String {
     #[inline]
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
         PyStr::from(self).into_ref(vm)
     }
 }
 
-impl TryIntoRef<PyStr> for &str {
+impl IntoPyStrRef for &str {
     #[inline]
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
         PyStr::from(self).into_ref(vm)
     }
 }

vm/src/pyobject.rs

@@ -407,11 +407,6 @@ impl<T: PyValue> IntoPyObject for PyRefExact<T> {
         self.obj.into()
     }
 }
-impl<T: PyValue> TryIntoRef<T> for PyRefExact<T> {
-    fn try_into_ref(self, _vm: &VirtualMachine) -> PyRef<T> {
-        self.obj
-    }
-}
 
 pub trait IdProtocol {
     fn get_id(&self) -> usize;
@@ -613,19 +608,6 @@ impl<T: TryFromObject> TryFromObject for Option<T> {
     }
 }
 
-/// Allows coercion of a types into PyRefs, so that we can write functions that can take
-/// refs, pyobject refs or basic types.
-pub trait TryIntoRef<T: PyObjectPayload> {
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyRef<T>;
-}
-
-impl<T: PyObjectPayload> TryIntoRef<T> for PyRef<T> {
-    #[inline]
-    fn try_into_ref(self, _vm: &VirtualMachine) -> PyRef<T> {
-        self
-    }
-}
-
 /// Implemented by any type that can be created from a Python object.
 ///
 /// Any type that implements `TryFromObject` is automatically `FromArgs`, and

vm/src/scope.rs

@@ -1,10 +1,10 @@
+use crate::{
+    builtins::{pystr::IntoPyStrRef, PyDictRef, PyStrRef},
+    function::IntoPyObject,
+    ItemProtocol, VirtualMachine,
+};
 use std::fmt;
 
-use crate::builtins::{PyDictRef, PyStr, PyStrRef};
-use crate::function::IntoPyObject;
-use crate::VirtualMachine;
-use crate::{ItemProtocol, TryIntoRef};
-
 #[derive(Clone)]
 pub struct Scope {
     pub locals: PyDictRef,
@@ -145,7 +145,7 @@ mod sealed {
     impl Sealed for super::PyStrRef {}
 }
 pub trait PyName:
-    sealed::Sealed + crate::dictdatatype::DictKey + Clone + IntoPyObject + TryIntoRef<PyStr>
+    sealed::Sealed + crate::dictdatatype::DictKey + Clone + IntoPyObject + IntoPyStrRef
 {
 }
 impl PyName for &str {}

vm/src/vm.rs

@@ -10,6 +10,7 @@ use crate::{
     builtins::{
         code::{self, PyCode},
         module, object,
+        pystr::IntoPyStrRef,
         tuple::{IntoPyTuple, PyTuple, PyTupleRef, PyTupleTyped},
         PyBaseException, PyBaseExceptionRef, PyDictRef, PyInt, PyIntRef, PyList, PyModule, PyStr,
         PyStrRef, PyTypeRef,
@@ -29,7 +30,7 @@ use crate::{
     stdlib,
     utils::Either,
     IdProtocol, ItemProtocol, PyArithmeticValue, PyContext, PyLease, PyMethod, PyObject,
-    PyObjectRef, PyRef, PyRefExact, PyResult, PyValue, TryFromObject, TryIntoRef, TypeProtocol,
+    PyObjectRef, PyRef, PyRefExact, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::{Signed, ToPrimitive};
@@ -800,14 +801,10 @@ impl VirtualMachine {
         syntax_error
     }
 
-    pub fn new_import_error(
-        &self,
-        msg: String,
-        name: impl TryIntoRef<PyStr>,
-    ) -> PyBaseExceptionRef {
+    pub fn new_import_error(&self, msg: String, name: impl IntoPyStrRef) -> PyBaseExceptionRef {
         let import_error = self.ctx.exceptions.import_error.clone();
         let exc = self.new_exception_msg(import_error, msg);
-        self.set_attr(exc.as_object(), "name", name.try_into_ref(self))
+        self.set_attr(exc.as_object(), "name", name.into_pystr_ref(self))
             .unwrap();
         exc
     }
@@ -938,11 +935,11 @@ impl VirtualMachine {
     #[inline]
     pub fn import(
         &self,
-        module: impl TryIntoRef<PyStr>,
+        module: impl IntoPyStrRef,
         from_list: Option<PyTupleTyped<PyStrRef>>,
         level: usize,
     ) -> PyResult {
-        self._import_inner(module.try_into_ref(self), from_list, level)
+        self._import_inner(module.into_pystr_ref(self), from_list, level)
     }
 
     fn _import_inner(
@@ -1399,9 +1396,9 @@ impl VirtualMachine {
     #[cfg_attr(feature = "flame-it", flame("VirtualMachine"))]
     pub fn get_attribute<T>(&self, obj: PyObjectRef, attr_name: T) -> PyResult
     where
-        T: TryIntoRef<PyStr>,
+        T: IntoPyStrRef,
     {
-        let attr_name = attr_name.try_into_ref(self);
+        let attr_name = attr_name.into_pystr_ref(self);
         vm_trace!("vm.__getattribute__: {:?} {:?}", obj, attr_name);
         let getattro = obj
             .class()
@@ -1416,7 +1413,7 @@ impl VirtualMachine {
         attr_name: T,
     ) -> PyResult<Option<PyObjectRef>>
     where
-        T: TryIntoRef<PyStr>,
+        T: IntoPyStrRef,
     {
         match self.get_attribute(obj, attr_name) {
             Ok(attr) => Ok(Some(attr)),
@@ -1451,15 +1448,15 @@ impl VirtualMachine {
 
     pub fn set_attr<K, V>(&self, obj: &PyObjectRef, attr_name: K, attr_value: V) -> PyResult<()>
     where
-        K: TryIntoRef<PyStr>,
+        K: IntoPyStrRef,
         V: Into<PyObjectRef>,
     {
-        let attr_name = attr_name.try_into_ref(self);
+        let attr_name = attr_name.into_pystr_ref(self);
         self.call_set_attr(obj, attr_name, Some(attr_value.into()))
     }
 
-    pub fn del_attr(&self, obj: &PyObjectRef, attr_name: impl TryIntoRef<PyStr>) -> PyResult<()> {
-        let attr_name = attr_name.try_into_ref(self);
+    pub fn del_attr(&self, obj: &PyObjectRef, attr_name: impl IntoPyStrRef) -> PyResult<()> {
+        let attr_name = attr_name.into_pystr_ref(self);
         self.call_set_attr(obj, attr_name, None)
     }
 
@@ -2169,11 +2166,11 @@ impl VirtualMachine {
     pub fn __module_set_attr(
         &self,
         module: &PyObjectRef,
-        attr_name: impl TryIntoRef<PyStr>,
+        attr_name: impl IntoPyStrRef,
         attr_value: impl Into<PyObjectRef>,
     ) -> PyResult<()> {
         let val = attr_value.into();
-        object::setattr(module, attr_name.try_into_ref(self), Some(val), self)
+        object::setattr(module, attr_name.into_pystr_ref(self), Some(val), self)
     }
 }