type.__name__ & getattr optimization

Author: youknowone

src/shell/helper.rs

@@ -78,7 +78,8 @@ impl<'vm> ShellHelper<'vm> {
             let mut current = self.globals.get_item_opt(first.as_str(), self.vm).ok()??;
 
             for attr in parents {
-                current = current.get_attr(attr.as_str(), self.vm).ok()?;
+                let attr = self.vm.ctx.new_str(attr.as_str());
+                current = current.get_attr(&attr, self.vm).ok()?;
             }
 
             let current_iter = str_iter_method(current, identifier!(self.vm, __dir__)).ok()?;

stdlib/src/ssl.rs

@@ -230,7 +230,7 @@ mod _ssl {
     /// SSL/TLS connection terminated abruptly.
     #[pyattr(name = "SSLEOFError", once)]
     fn ssl_eof_error(vm: &VirtualMachine) -> PyTypeRef {
-        PyType::new_simple_ref("ssl.SSLEOFError", &ssl_error(vm), &vm.ctx).unwrap()
+        PyType::new_simple_heap("ssl.SSLEOFError", &ssl_error(vm), &vm.ctx).unwrap()
     }
 
     type OpensslVersionInfo = (u8, u8, u8, u8, u8);

vm/src/builtins/builtin_func.rs

@@ -259,7 +259,7 @@ impl PyBuiltinMethod {
         vm: &VirtualMachine,
     ) -> (Option<PyObjectRef>, (Option<PyObjectRef>, PyStrRef)) {
         let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
-        let classname = vm.builtins.get_attr(self.class.name().to_string(), vm).ok();
+        let classname = vm.builtins.get_attr(&self.class.__name__(vm), vm).ok();
         (builtins_getattr, (classname, self.value.name.clone()))
     }
 }

vm/src/builtins/function.rs

@@ -501,10 +501,10 @@ impl Comparable for PyBoundMethod {
 }
 
 impl GetAttr for PyBoundMethod {
-    fn getattro(zelf: &Py<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         let class_attr = vm
             .ctx
-            .interned_str(&*name)
+            .interned_str(name)
             .and_then(|attr_name| zelf.get_class_attr(attr_name));
         if let Some(obj) = class_attr {
             return vm.call_if_get_descriptor(obj, zelf.to_owned().into());

vm/src/builtins/genericalias.rs

@@ -3,7 +3,7 @@ use once_cell::sync::Lazy;
 use super::type_;
 use crate::{
     atomic_func,
-    builtins::{PyList, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef},
+    builtins::{PyList, PyStr, PyTuple, PyTupleRef, PyType, PyTypeRef},
     class::PyClassImpl,
     common::hash,
     convert::ToPyObject,
@@ -216,7 +216,7 @@ impl PyGenericAlias {
 
 fn is_typevar(obj: &PyObjectRef, vm: &VirtualMachine) -> bool {
     let class = obj.class();
-    class.slot_name() == "TypeVar"
+    "TypeVar" == &*class.slot_name()
         && class
             .get_attr(identifier!(vm, __module__))
             .and_then(|o| o.downcast_ref::<PyStr>().map(|s| s.as_str() == "typing"))
@@ -390,10 +390,10 @@ impl Hashable for PyGenericAlias {
 }
 
 impl GetAttr for PyGenericAlias {
-    fn getattro(zelf: &Py<Self>, attr: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         for exc in ATTR_EXCEPTIONS.iter() {
             if *(*exc) == attr.to_string() {
-                return zelf.as_object().generic_getattr(&attr, vm);
+                return zelf.as_object().generic_getattr(attr, vm);
             }
         }
         zelf.origin().get_attr(attr, vm)

vm/src/builtins/module.rs

@@ -1,7 +1,7 @@
 use super::pystr::IntoPyStrRef;
 use super::{PyDictRef, PyStr, PyStrRef, PyType, PyTypeRef};
 use crate::{
-    builtins::PyStrInterned,
+    builtins::{pystr::AsPyStr, PyStrInterned},
     class::PyClassImpl,
     convert::ToPyObject,
     function::FuncArgs,
@@ -30,29 +30,24 @@ impl PyModule {
     // pub(crate) fn new(d: PyDictRef) -> Self {
     //     PyModule { dict: d.into() }
     // }
+}
 
-    // #[inline]
-    // pub fn dict(&self) -> PyDictRef {
-    //     self.dict.get()
-    // }
-
-    fn getattr_inner(zelf: &Py<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        if let Some(attr) = zelf.as_object().generic_getattr_opt(&name, None, vm)? {
+impl Py<PyModule> {
+    fn getattr_inner(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        if let Some(attr) = self.as_object().generic_getattr_opt(name, None, vm)? {
             return Ok(attr);
         }
-        if let Ok(getattr) = zelf.dict().get_item(identifier!(vm, __getattr__), vm) {
-            return getattr.call((name,), vm);
+        if let Ok(getattr) = self.dict().get_item(identifier!(vm, __getattr__), vm) {
+            return getattr.call((name.to_owned(),), vm);
         }
-        let module_name = if let Some(name) = zelf.name(vm) {
+        let module_name = if let Some(name) = self.name(vm) {
             format!(" '{name}'")
         } else {
             "".to_owned()
         };
         Err(vm.new_attribute_error(format!("module{module_name} has no attribute '{name}'")))
     }
-}
 
-impl Py<PyModule> {
     fn name(&self, vm: &VirtualMachine) -> Option<PyStrRef> {
         let name = self
             .as_object()
@@ -85,9 +80,10 @@ impl Py<PyModule> {
             .expect("Failed to set __spec__ on module");
     }
 
-    pub fn get_attr(&self, attr_name: impl IntoPyStrRef, vm: &VirtualMachine) -> PyResult {
-        PyModule::getattr_inner(self, attr_name.into_pystr_ref(vm), vm)
+    pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
+        self.getattr_inner(attr_name.as_pystr(&vm.ctx), vm)
     }
+
     pub fn set_attr(
         &self,
         attr_name: impl IntoPyStrRef,
@@ -135,8 +131,8 @@ impl Initializer for PyModule {
 }
 
 impl GetAttr for PyModule {
-    fn getattro(zelf: &Py<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        Self::getattr_inner(zelf, name, vm)
+    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        zelf.getattr_inner(name, vm)
     }
 }
 

vm/src/builtins/namespace.rs

@@ -82,7 +82,7 @@ impl Representable for PyNamespace {
         let name = if o.class().is(vm.ctx.types.namespace_type) {
             "namespace".to_owned()
         } else {
-            o.class().slot_name()
+            o.class().slot_name().to_owned()
         };
 
         let repr = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {

vm/src/builtins/object.rs

@@ -296,14 +296,14 @@ impl PyBaseObject {
 
     /// Return getattr(self, name).
     #[pyslot]
-    pub(crate) fn getattro(obj: &PyObject, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    pub(crate) fn getattro(obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         vm_trace!("object.__getattribute__({:?}, {:?})", obj, name);
-        obj.as_object().generic_getattr(&name, vm)
+        obj.as_object().generic_getattr(name, vm)
     }
 
     #[pymethod(magic)]
     fn getattribute(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        Self::getattro(&obj, name, vm)
+        Self::getattro(&obj, &name, vm)
     }
 
     #[pymethod(magic)]

vm/src/builtins/str.rs

@@ -189,6 +189,42 @@ impl IntoPyStrRef for &'static PyStrInterned {
     }
 }
 
+pub trait AsPyStr<'a>
+where
+    Self: 'a,
+{
+    #[allow(clippy::wrong_self_convention)] // to implement on refs
+    fn as_pystr(self, ctx: &Context) -> &'a Py<PyStr>;
+}
+
+impl<'a> AsPyStr<'a> for &'a Py<PyStr> {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
+impl<'a> AsPyStr<'a> for &'a PyStrRef {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
+impl AsPyStr<'static> for &'static str {
+    #[inline]
+    fn as_pystr(self, ctx: &Context) -> &'static Py<PyStr> {
+        ctx.intern_str(self)
+    }
+}
+
+impl<'a> AsPyStr<'a> for &'a PyStrInterned {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
 #[pyclass(module = false, name = "str_iterator")]
 #[derive(Debug)]
 pub struct PyStrIterator {

vm/src/builtins/super.rs

@@ -3,7 +3,7 @@
 See also [CPython source code.](https://github.com/python/cpython/blob/50b48572d9a90c5bb36e2bef6179548ea927a35a/Objects/typeobject.c#L7663)
 */
 
-use super::{PyStrRef, PyType, PyTypeRef};
+use super::{PyStr, PyType, PyTypeRef};
 use crate::{
     class::PyClassImpl,
     function::{IntoFuncArgs, OptionalArg},
@@ -126,20 +126,20 @@ impl PySuper {
 }
 
 impl GetAttr for PySuper {
-    fn getattro(zelf: &Py<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         let skip = |zelf: &Py<Self>, name| zelf.as_object().generic_getattr(name, vm);
         let (obj, start_type): (PyObjectRef, PyTypeRef) = match zelf.obj.clone() {
             Some(o) => o,
-            None => return skip(zelf, &name),
+            None => return skip(zelf, name),
         };
         // We want __class__ to return the class of the super object
         // (i.e. super, or a subclass), not the class of su->obj.
 
         if name.as_str() == "__class__" {
-            return skip(zelf, &name);
+            return skip(zelf, name);
         }
 
-        if let Some(name) = vm.ctx.interned_str(&*name) {
+        if let Some(name) = vm.ctx.interned_str(name) {
             // skip the classes in start_type.mro up to and including zelf.typ
             let mro: Vec<_> = start_type
                 .iter_mro()
@@ -159,7 +159,7 @@ impl GetAttr for PySuper {
                 }
             }
         }
-        skip(zelf, &name)
+        skip(zelf, name)
     }
 }