Merge pull request RustPython#3273 from youknowone/into-pystrref

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,24 +169,42 @@ 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 into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+        self.into_ref(vm)
+    }
+}
+
+impl IntoPyStrRef for AsciiString {
     #[inline]
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
-        Ok(unsafe { PyStr::new_ascii_unchecked(self.into()) }.into_ref(vm))
+    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) -> PyResult<PyRef<PyStr>> {
-        Ok(PyStr::from(self).into_ref(vm))
+    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) -> PyResult<PyRef<PyStr>> {
-        Ok(PyStr::from(self).into_ref(vm))
+    fn into_pystr_ref(self, vm: &VirtualMachine) -> PyRef<PyStr> {
+        PyStr::from(self).into_ref(vm)
     }
 }
 

vm/src/builtins/slice.rs

@@ -3,8 +3,8 @@ use super::{PyInt, PyIntRef, PyTupleRef, PyTypeRef};
 use crate::{
     function::{FuncArgs, IntoPyObject, OptionalArg},
     slots::{Comparable, Hashable, PyComparisonOp, SlotConstructor, Unhashable},
-    PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryIntoRef,
-    TypeProtocol, VirtualMachine,
+    PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    VirtualMachine,
 };
 use num_bigint::{BigInt, ToBigInt};
 use num_traits::{One, Signed, ToPrimitive, Zero};
@@ -115,7 +115,7 @@ impl PySlice {
             step = One::one();
         } else {
             // Clone the value, not the reference.
-            let this_step: PyRef<PyInt> = self.step(vm).try_into_ref(vm)?;
+            let this_step: PyRef<PyInt> = self.step(vm).try_into_value(vm)?;
             step = this_step.as_bigint().clone();
 
             if step.is_zero() {
@@ -149,7 +149,7 @@ impl PySlice {
                 lower.clone()
             };
         } else {
-            let this_start: PyRef<PyInt> = self.start(vm).try_into_ref(vm)?;
+            let this_start: PyRef<PyInt> = self.start(vm).try_into_value(vm)?;
             start = this_start.as_bigint().clone();
 
             if start < Zero::zero() {
@@ -169,7 +169,7 @@ impl PySlice {
         if vm.is_none(&self.stop) {
             stop = if backwards { lower } else { upper };
         } else {
-            let this_stop: PyRef<PyInt> = self.stop(vm).try_into_ref(vm)?;
+            let this_stop: PyRef<PyInt> = self.stop(vm).try_into_value(vm)?;
             stop = this_stop.as_bigint().clone();
 
             if stop < Zero::zero() {

vm/src/builtins/weakproxy.rs

@@ -47,14 +47,14 @@ impl SlotConstructor for PyWeakProxy {
 impl PyWeakProxy {
     // TODO: callbacks
     #[pymethod(magic)]
-    fn getattr(&self, attr_name: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        match self.weak.upgrade() {
-            Some(obj) => vm.get_attribute(obj, attr_name),
-            None => Err(vm.new_exception_msg(
+    fn getattr(&self, attr_name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        let obj = self.weak.upgrade().ok_or_else(|| {
+            vm.new_exception_msg(
                 vm.ctx.exceptions.reference_error.clone(),
                 "weakly-referenced object no longer exists".to_owned(),
-            )),
-        }
+            )
+        })?;
+        vm.get_attribute(obj, attr_name)
     }
 }
 

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) -> PyResult<PyRef<T>> {
-        Ok(self.obj)
-    }
-}
 
 pub trait IdProtocol {
     fn get_id(&self) -> usize;
@@ -613,28 +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) -> PyResult<PyRef<T>>;
-}
-
-impl<T: PyObjectPayload> TryIntoRef<T> for PyRef<T> {
-    #[inline]
-    fn try_into_ref(self, _vm: &VirtualMachine) -> PyResult<PyRef<T>> {
-        Ok(self)
-    }
-}
-
-impl<T> TryIntoRef<T> for PyObjectRef
-where
-    T: PyValue,
-{
-    fn try_into_ref(self, vm: &VirtualMachine) -> PyResult<PyRef<T>> {
-        TryFromObject::try_from_object(vm, 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/stdlib/errno.rs

@@ -7,9 +7,11 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "errorcode" => errorcode.clone(),
     });
     for (name, code) in ERROR_CODES {
-        let name = vm.new_pyobj(*name);
+        let name = vm.ctx.new_str(*name);
         let code = vm.new_pyobj(*code);
-        errorcode.set_item(code.clone(), name.clone(), vm).unwrap();
+        errorcode
+            .set_item(code.clone(), name.clone().into(), vm)
+            .unwrap();
         vm.set_attr(&module, name, code).unwrap();
     }
     module

vm/src/stdlib/operator.rs

@@ -21,7 +21,7 @@ mod _operator {
         },
         utils::Either,
         vm::ReprGuard,
-        IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TryIntoRef, TypeProtocol,
+        IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
         VirtualMachine,
     };
 
@@ -444,7 +444,7 @@ mod _operator {
             }
             let mut attrs = Vec::with_capacity(nattr);
             for o in args.args {
-                if let Ok(r) = o.try_into_ref(vm) {
+                if let Ok(r) = o.try_into_value(vm) {
                     attrs.push(r);
                 } else {
                     return Err(vm.new_type_error("attribute name must be a string".to_owned()));
@@ -598,7 +598,7 @@ mod _operator {
         type Args = (PyObjectRef, FuncArgs);
 
         fn py_new(cls: PyTypeRef, (name, args): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if let Ok(name) = name.try_into_ref(vm) {
+            if let Ok(name) = name.try_into_value(vm) {
                 PyMethodCaller { name, args }.into_pyresult_with_type(vm, cls)
             } else {
                 Err(vm.new_type_error("method name must be a string".to_owned()))

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).unwrap())
+        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)
     }
 }