&'static PySequenceMethods

Author: youknowone

vm/src/builtins/iter.rs

@@ -14,7 +14,6 @@ use rustpython_common::{
     lock::{PyMutex, PyRwLock, PyRwLockUpgradableReadGuard},
     static_cell,
 };
-use std::borrow::Cow;
 
 /// Marks status of iterator.
 #[derive(Debug, Clone)]
@@ -163,7 +162,7 @@ pub fn builtins_reversed(vm: &VirtualMachine) -> &PyObject {
 #[derive(Debug)]
 pub struct PySequenceIterator {
     // cached sequence methods
-    seq_methods: Cow<'static, PySequenceMethods>,
+    seq_methods: &'static PySequenceMethods,
     internal: PyMutex<PositionIterInternal<PyObjectRef>>,
 }
 
@@ -177,9 +176,8 @@ impl PyPayload for PySequenceIterator {
 impl PySequenceIterator {
     pub fn new(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         let seq = PySequence::try_protocol(obj.as_ref(), vm)?;
-        let seq_methods = seq.methods_cow(vm).clone();
         Ok(Self {
-            seq_methods,
+            seq_methods: seq.methods,
             internal: PyMutex::new(PositionIterInternal::new(obj, 0)),
         })
     }
@@ -188,7 +186,7 @@ impl PySequenceIterator {
     fn length_hint(&self, vm: &VirtualMachine) -> PyObjectRef {
         let internal = self.internal.lock();
         if let IterStatus::Active(obj) = &internal.status {
-            let seq = PySequence::with_methods(obj, self.seq_methods.clone());
+            let seq = PySequence::with_methods(obj, self.seq_methods);
             seq.length(vm)
                 .map(|x| PyInt::from(x).into_pyobject(vm))
                 .unwrap_or_else(|_| vm.ctx.not_implemented())
@@ -212,7 +210,7 @@ impl IterNextIterable for PySequenceIterator {}
 impl IterNext for PySequenceIterator {
     fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         zelf.internal.lock().next(|obj, pos| {
-            let seq = PySequence::with_methods(obj, zelf.seq_methods.clone());
+            let seq = PySequence::with_methods(obj, zelf.seq_methods);
             PyIterReturn::from_getitem_result(seq.get_item(pos as isize, vm), vm)
         })
     }

vm/src/builtins/list.rs

@@ -139,7 +139,7 @@ impl PyList {
     }
 
     fn inplace_concat(zelf: &Py<Self>, other: &PyObject, vm: &VirtualMachine) -> PyObjectRef {
-        if let Ok(mut seq) = PySequence::from(other).extract_cloned(Ok, vm) {
+        if let Ok(mut seq) = extract_cloned(other, Ok, vm) {
             zelf.borrow_vec_mut().append(&mut seq);
             zelf.to_owned().into()
         } else {
@@ -149,7 +149,7 @@ impl PyList {
 
     #[pymethod(magic)]
     fn iadd(zelf: PyRef<Self>, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        if let Ok(mut seq) = PySequence::from(other.as_ref()).extract_cloned(Ok, vm) {
+        if let Ok(mut seq) = extract_cloned(&*other, Ok, vm) {
             zelf.borrow_vec_mut().append(&mut seq);
             zelf.into()
         } else {
@@ -215,7 +215,7 @@ impl PyList {
         match SequenceIndex::try_from_borrowed_object(vm, needle)? {
             SequenceIndex::Int(index) => self.borrow_vec_mut().set_item_by_index(vm, index, value),
             SequenceIndex::Slice(slice) => {
-                let sec = PySequence::from(value.as_ref()).extract_cloned(Ok, vm)?;
+                let sec = extract_cloned(&*value, Ok, vm)?;
                 self.borrow_vec_mut().set_item_by_slice(vm, slice, &sec)
             }
         }
@@ -352,6 +352,31 @@ impl PyList {
     }
 }
 
+fn extract_cloned<F, R>(obj: &PyObject, mut f: F, vm: &VirtualMachine) -> PyResult<Vec<R>>
+where
+    F: FnMut(PyObjectRef) -> PyResult<R>,
+{
+    use crate::builtins::PyTuple;
+    if let Some(tuple) = obj.payload_if_exact::<PyTuple>(vm) {
+        tuple.iter().map(|x| f(x.clone())).collect()
+    } else if let Some(list) = obj.payload_if_exact::<PyList>(vm) {
+        list.borrow_vec().iter().map(|x| f(x.clone())).collect()
+    } else {
+        let iter = obj.to_owned().get_iter(vm)?;
+        let iter = iter.iter::<PyObjectRef>(vm)?;
+        let len = PySequence::new(obj, vm)
+            .and_then(|seq| seq.length_opt(vm))
+            .transpose()?
+            .unwrap_or(0);
+        let mut v = Vec::with_capacity(len);
+        for x in iter {
+            v.push(f(x?)?);
+        }
+        v.shrink_to_fit();
+        Ok(v)
+    }
+}
+
 impl<'a> MutObjectSequenceOp<'a> for PyList {
     type Guard = PyMappedRwLockReadGuard<'a, [PyObjectRef]>;
 

vm/src/builtins/mappingproxy.rs

@@ -91,7 +91,7 @@ impl PyMappingProxy {
             MappingProxyInner::Class(class) => Ok(key
                 .as_interned_str(vm)
                 .map_or(false, |key| class.attributes.read().contains_key(key))),
-            MappingProxyInner::Mapping(obj) => PySequence::from(obj.as_ref()).contains(key, vm),
+            MappingProxyInner::Mapping(mapping) => PySequence::contains(&*mapping, key, vm),
         }
     }
 

vm/src/protocol/mapping.rs

@@ -69,9 +69,7 @@ impl PyMapping<'_> {
     // PyMapping::Check
     #[inline]
     pub fn check(obj: &PyObject, vm: &VirtualMachine) -> bool {
-        Self::find_methods(obj, vm)
-            .and_then(|m| m.subscript)
-            .is_some()
+        Self::find_methods(obj, vm).map_or(false, PyMappingMethods::check)
     }
 
     pub fn find_methods(obj: &PyObject, vm: &VirtualMachine) -> Option<&'static PyMappingMethods> {

vm/src/protocol/object.rs

@@ -522,8 +522,8 @@ impl PyObject {
     // int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)
 
     pub fn length_opt(&self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        PySequence::from(self)
-            .length_opt(vm)
+        PySequence::new(self, vm)
+            .and_then(|seq| seq.length_opt(vm))
             .or_else(|| PyMapping::new(self, vm).and_then(|mapping| mapping.length_opt(vm)))
     }
 
@@ -576,17 +576,17 @@ impl PyObject {
                 return f(&mapping, &needle, Some(value), vm);
             }
         }
-
-        let seq = PySequence::from(self);
-        if let Some(f) = seq.methods(vm).ass_item {
-            let i = needle.key_as_isize(vm)?;
-            f(&seq, i, Some(value), vm)
-        } else {
-            Err(vm.new_type_error(format!(
-                "'{}' does not support item assignment",
-                self.class()
-            )))
+        if let Some(seq) = PySequence::new(self, vm) {
+            if let Some(f) = seq.methods.ass_item {
+                let i = needle.key_as_isize(vm)?;
+                return f(&seq, i, Some(value), vm);
+            }
         }
+
+        Err(vm.new_type_error(format!(
+            "'{}' does not support item assignment",
+            self.class()
+        )))
     }
 
     pub fn del_item<K: DictKey + ?Sized>(&self, needle: &K, vm: &VirtualMachine) -> PyResult<()> {
@@ -600,14 +600,13 @@ impl PyObject {
                 return f(&mapping, &needle, None, vm);
             }
         }
-
-        let seq = PySequence::from(self);
-
-        if let Some(f) = seq.methods(vm).ass_item {
-            let i = needle.key_as_isize(vm)?;
-            f(&seq, i, None, vm)
-        } else {
-            Err(vm.new_type_error(format!("'{}' does not support item deletion", self.class())))
+        if let Some(seq) = PySequence::new(self, vm) {
+            if let Some(f) = seq.methods.ass_item {
+                let i = needle.key_as_isize(vm)?;
+                return f(&seq, i, None, vm);
+            }
         }
+
+        Err(vm.new_type_error(format!("'{}' does not support item deletion", self.class())))
     }
 }