Merge pull request RustPython#3261 from Snowapril/fix-issue-3232

Modify `PyType::name` method to return `BorrowedValue<str>`

Author: youknowone

common/src/borrow.rs

@@ -2,7 +2,10 @@ use crate::lock::{
     MapImmutable, PyImmutableMappedMutexGuard, PyMappedMutexGuard, PyMappedRwLockReadGuard,
     PyMappedRwLockWriteGuard, PyMutexGuard, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
-use std::ops::{Deref, DerefMut};
+use std::{
+    fmt,
+    ops::{Deref, DerefMut},
+};
 
 macro_rules! impl_from {
     ($lt:lifetime, $gen:ident, $t:ty, $($var:ident($from:ty),)*) => {
@@ -64,6 +67,12 @@ impl<T: ?Sized> Deref for BorrowedValue<'_, T> {
     }
 }
 
+impl fmt::Display for BorrowedValue<'_, str> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self.deref(), f)
+    }
+}
+
 #[derive(Debug)]
 pub enum BorrowedValueMut<'a, T: ?Sized> {
     RefMut(&'a mut T),

stdlib/src/array.rs

@@ -1036,7 +1036,8 @@ mod array {
 
         #[pymethod(magic)]
         fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let class_name = zelf.class().name();
+            let class = zelf.class();
+            let class_name = class.name();
             if zelf.read().typecode() == 'u' {
                 if zelf.len() == 0 {
                     return Ok(format!("{}('u')", class_name));

vm/src/builtins/bytearray.rs

@@ -128,7 +128,8 @@ impl PyByteArray {
 
     #[pymethod(magic)]
     fn repr(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        let class_name = zelf.class().name();
+        let class = zelf.class();
+        let class_name = class.name();
         let s = zelf.inner().repr(Some(&class_name));
         Ok(s)
     }

vm/src/builtins/object.rs

@@ -254,7 +254,8 @@ impl PyBaseObject {
                     Ok(())
                 }
                 Err(value) => {
-                    let type_repr = &value.class().name();
+                    let value_class = value.class();
+                    let type_repr = &value_class.name();
                     Err(vm.new_type_error(format!(
                         "__class__ must be set to a class, not '{}' object",
                         type_repr

vm/src/builtins/pybool.rs

@@ -97,7 +97,8 @@ impl SlotConstructor for PyBool {
 
     fn py_new(zelf: PyTypeRef, x: Self::Args, vm: &VirtualMachine) -> PyResult {
         if !zelf.isinstance(&vm.ctx.types.type_type) {
-            let actual_type = &zelf.class().name();
+            let actual_class = zelf.class();
+            let actual_type = &actual_class.name();
             return Err(vm.new_type_error(format!(
                 "requires a 'type' object but received a '{}'",
                 actual_type

vm/src/builtins/pystr.rs

@@ -1463,6 +1463,7 @@ fn char_is_printable(c: char) -> bool {
 mod tests {
     use super::*;
     use crate::Interpreter;
+    use std::ops::Deref;
 
     #[test]
     fn str_title() {
@@ -1531,7 +1532,7 @@ mod tests {
             assert_eq!(translated, "🎅xda".to_owned());
             let translated = text.translate(vm.ctx.new_int(3), &vm);
             assert_eq!(
-                translated.unwrap_err().class().name(),
+                translated.unwrap_err().class().name().deref(),
                 "TypeError".to_owned()
             );
         })

vm/src/builtins/pytype.rs

@@ -2,7 +2,11 @@ use super::{
     mappingproxy::PyMappingProxy, object, PyClassMethod, PyDictRef, PyInt, PyList, PyStaticMethod,
     PyStr, PyStrRef, PyTuple, PyTupleRef, PyWeak,
 };
-use crate::common::{ascii, lock::PyRwLock};
+use crate::common::{
+    ascii,
+    borrow::BorrowedValue,
+    lock::{PyRwLock, PyRwLockReadGuard},
+};
 use crate::{
     function::{FuncArgs, KwArgs, OptionalArg},
     protocol::{PyIterReturn, PyMappingMethods},
@@ -400,9 +404,16 @@ impl PyType {
         vm.ctx.not_implemented()
     }
 
-    #[pyproperty(magic)]
-    pub fn name(&self) -> String {
-        self.slot_name().rsplit('.').next().unwrap().to_string()
+    #[pyproperty]
+    fn __name__(&self) -> String {
+        self.name().to_string()
+    }
+
+    pub fn name(&self) -> BorrowedValue<str> {
+        PyRwLockReadGuard::map(self.slots.name.read(), |slot_name| {
+            slot_name.as_ref().unwrap().rsplit('.').next().unwrap()
+        })
+        .into()
     }
 
     #[pymethod(magic)]
@@ -440,7 +451,7 @@ impl PyType {
                     Some(found)
                 }
             })
-            .unwrap_or_else(|| vm.ctx.new_utf8_str(self.name()))
+            .unwrap_or_else(|| vm.ctx.new_utf8_str(self.name().deref()))
     }
 
     #[pyproperty(magic)]
@@ -653,7 +664,7 @@ impl PyType {
     fn text_signature(&self) -> Option<String> {
         self.slots
             .doc
-            .and_then(|doc| get_text_signature_from_internal_doc(self.name().as_str(), doc))
+            .and_then(|doc| get_text_signature_from_internal_doc(&self.name(), doc))
             .map(|signature| signature.to_string())
     }
 }

vm/src/builtins/set.rs

@@ -15,7 +15,7 @@ use crate::{
     IdProtocol, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
     TryFromObject, TypeProtocol,
 };
-use std::fmt;
+use std::{fmt, ops::Deref};
 
 pub type SetContentType = dictdatatype::Dict<()>;
 
@@ -512,12 +512,14 @@ impl PySet {
 
     #[pymethod(magic)]
     fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-        let class_name = zelf.class().name();
+        let class = zelf.class();
+        let borrowed_name = class.name();
+        let class_name = borrowed_name.deref();
         let s = if zelf.inner.len() == 0 {
             format!("{}()", class_name)
         } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let name = if class_name != "set" {
-                Some(class_name.as_str())
+                Some(class_name)
             } else {
                 None
             };
@@ -790,7 +792,8 @@ impl PyFrozenSet {
     #[pymethod(magic)]
     fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
         let inner = &zelf.inner;
-        let class_name = zelf.class().name();
+        let class = zelf.class();
+        let class_name = class.name();
         let s = if inner.len() == 0 {
             format!("{}()", class_name)
         } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {

vm/src/exceptions.rs

@@ -15,6 +15,7 @@ use itertools::Itertools;
 use std::{
     collections::HashSet,
     io::{self, BufRead, BufReader},
+    ops::Deref,
 };
 
 impl std::fmt::Debug for PyBaseException {
@@ -175,7 +176,8 @@ pub fn write_exception_inner<W: Write>(
     let varargs = exc.args();
     let args_repr = exception_args_as_string(vm, varargs, true);
 
-    let exc_name = exc.class().name();
+    let exc_class = exc.class();
+    let exc_name = exc_class.name();
     match args_repr.len() {
         0 => writeln!(output, "{}", exc_name),
         1 => writeln!(output, "{}: {}", exc_name, args_repr[0]),
@@ -878,7 +880,7 @@ impl serde::Serialize for SerializeException<'_> {
         use serde::ser::*;
 
         let mut struc = s.serialize_struct("PyBaseException", 7)?;
-        struc.serialize_field("exc_type", &self.exc.class().name())?;
+        struc.serialize_field("exc_type", self.exc.class().name().deref())?;
         let tbs = {
             struct Tracebacks(PyTracebackRef);
             impl serde::Serialize for Tracebacks {
@@ -956,6 +958,7 @@ pub(super) mod types {
         PyObjectRef, PyRef, PyResult, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
+    use std::ops::Deref;
 
     // This module is designed to be used as `use builtins::*;`.
     // Do not add any pub symbols not included in builtins module.
@@ -1209,7 +1212,7 @@ pub(super) mod types {
         // We need this method, because of how `CPython` copies `init`
         // from `BaseException` in `SimpleExtendsException` macro.
         // See: `BaseException_new`
-        if cls.name() == vm.ctx.exceptions.os_error.name() {
+        if cls.name().deref() == vm.ctx.exceptions.os_error.name().deref() {
             match os_error_optional_new(args.args.to_vec(), vm) {
                 Some(error) => error.unwrap().into_pyresult(vm),
                 None => PyBaseException::slot_new(cls, args, vm),

vm/src/function.rs

@@ -182,7 +182,8 @@ impl FuncArgs {
                     Ok(Some(kwarg))
                 } else {
                     let expected_ty_name = &ty.name();
-                    let actual_ty_name = &kwarg.class().name();
+                    let kwarg_class = kwarg.class();
+                    let actual_ty_name = &kwarg_class.name();
                     Err(vm.new_type_error(format!(
                         "argument of type {} is required for named parameter `{}` (got: {})",
                         expected_ty_name, key, actual_ty_name

vm/src/pyobject.rs

@@ -442,7 +442,8 @@ pub(crate) fn pyref_type_error(
     obj: impl std::borrow::Borrow<PyObjectRef>,
 ) -> PyBaseExceptionRef {
     let expected_type = &*class.name();
-    let actual_type = &*obj.borrow().class().name();
+    let actual_class = obj.borrow().class();
+    let actual_type = &*actual_class.name();
     vm.new_type_error(format!(
         "Expected type '{}', not '{}'",
         expected_type, actual_type,

vm/src/stdlib/posix.rs

@@ -492,8 +492,9 @@ pub mod module {
         ))]
         fn try_to_libc(&self, vm: &VirtualMachine) -> PyResult<libc::sched_param> {
             use crate::TypeProtocol;
+            let priority_class = self.sched_priority.class();
+            let priority_type = priority_class.name();
             let priority = self.sched_priority.clone();
-            let priority_type = priority.class().name();
             let value = priority.downcast::<PyInt>().map_err(|_| {
                 vm.new_type_error(format!(
                     "an integer is required (got type {})",