Merge pull request RustPython#2194 from RustPython/coolreader18/deque-seq

Mini changes pulled from RustPython#2146

Author: youknowone

vm/src/cformat.rs

@@ -20,6 +20,7 @@ enum CFormatErrorType {
     UnescapedModuloSignInLiteral,
     UnsupportedFormatChar(char),
     IncompleteFormat,
+    IntTooBig,
     // Unimplemented,
 }
 
@@ -43,6 +44,7 @@ impl fmt::Display for CFormatError {
                 "unsupported format character '{}' ({:#x}) at index {}",
                 c, c as u32, self.index
             ),
+            IntTooBig => write!(f, "width/precision too big"),
             _ => write!(f, "unexpected error parsing format string"),
         }
     }
@@ -300,19 +302,32 @@ impl CFormatSpec {
                 self.format_string(result.borrow_value().to_owned())
             }
             CFormatType::Number(number_type) => {
-                if !objtype::isinstance(&obj, &vm.ctx.types.int_type) {
+                let err = || {
                     let required_type_string = match number_type {
                         CNumberType::Decimal => "a number",
                         _ => "an integer",
                     };
-                    return Err(vm.new_type_error(format!(
+                    vm.new_type_error(format!(
                         "%{} format: {} is required, not {}",
                         self.format_char,
                         required_type_string,
                         obj.lease_class()
-                    )));
-                }
-                self.format_number(objint::get_value(&obj))
+                    ))
+                };
+                match_class!(match &obj {
+                    ref i @ objint::PyInt => {
+                        self.format_number(i.borrow_value())
+                    }
+                    // TODO: if guards for match_class
+                    ref f @ objfloat::PyFloat => {
+                        if let CNumberType::Decimal = number_type {
+                            self.format_number(&objfloat::try_bigint(f.to_f64(), vm)?)
+                        } else {
+                            return Err(err());
+                        }
+                    }
+                    _ => return Err(err()),
+                })
             }
             CFormatType::Float(_) => {
                 let value = objfloat::try_float(&obj, vm)?.ok_or_else(|| {
@@ -420,25 +435,22 @@ impl CFormatString {
             mut tuple_index: usize,
         ) -> PyResult<usize> {
             match q {
-                Some(CFormatQuantity::FromValuesTuple) => {
-                    match elements.next() {
-                        Some(width_obj) => {
-                            tuple_index += 1;
-                            if !objtype::isinstance(&width_obj, &vm.ctx.types.int_type) {
-                                Err(vm.new_type_error("* wants int".to_owned()))
-                            } else {
-                                // TODO: handle errors when truncating BigInt to usize
-                                *q = Some(CFormatQuantity::Amount(
-                                    objint::get_value(&width_obj).to_usize().unwrap(),
-                                ));
-                                Ok(tuple_index)
-                            }
+                Some(CFormatQuantity::FromValuesTuple) => match elements.next() {
+                    Some(width_obj) => {
+                        tuple_index += 1;
+                        if !objtype::isinstance(&width_obj, &vm.ctx.types.int_type) {
+                            Err(vm.new_type_error("* wants int".to_owned()))
+                        } else {
+                            let i = objint::get_value(&width_obj);
+                            let i = objint::try_to_primitive::<isize>(i, vm)? as usize;
+                            *q = Some(CFormatQuantity::Amount(i));
+                            Ok(tuple_index)
                         }
-                        None => Err(
-                            vm.new_type_error("not enough arguments for format string".to_owned())
-                        ),
                     }
-                }
+                    None => {
+                        Err(vm.new_type_error("not enough arguments for format string".to_owned()))
+                    }
+                },
                 _ => Ok(tuple_index),
             }
         }
@@ -543,30 +555,30 @@ impl CFormatString {
     }
 }
 
-fn parse_quantity(text: &str) -> (Option<CFormatQuantity>, &str) {
+fn parse_quantity(text: &str) -> Result<(Option<CFormatQuantity>, &str), CFormatErrorType> {
     let num_digits: usize = get_num_digits(text);
-    if num_digits == 0 {
+    let ret = if num_digits == 0 {
         let mut chars = text.chars();
-        return match chars.next() {
+        match chars.next() {
             Some('*') => (Some(CFormatQuantity::FromValuesTuple), chars.as_str()),
             _ => (None, text),
-        };
-    }
-    // This should never fail
-    (
-        Some(CFormatQuantity::Amount(
-            text[..num_digits].parse::<usize>().unwrap(),
-        )),
-        &text[num_digits..],
-    )
+        }
+    } else {
+        let q = text[..num_digits]
+            .parse::<isize>()
+            .map_err(|_| CFormatErrorType::IntTooBig)? as usize;
+        (Some(CFormatQuantity::Amount(q)), &text[num_digits..])
+    };
+    Ok(ret)
 }
 
-fn parse_precision(text: &str) -> (Option<CFormatQuantity>, &str) {
+fn parse_precision(text: &str) -> Result<(Option<CFormatQuantity>, &str), CFormatErrorType> {
     let mut chars = text.chars();
-    match chars.next() {
-        Some('.') => parse_quantity(&chars.as_str()),
+    let ret = match chars.next() {
+        Some('.') => parse_quantity(&chars.as_str())?,
         _ => (None, text),
-    }
+    };
+    Ok(ret)
 }
 
 fn parse_literal_single(text: &str) -> Result<(char, &str), CFormatErrorType> {
@@ -794,8 +806,10 @@ impl FromStr for CFormatSpec {
         let (mapping_key, after_mapping_key) = parse_spec_mapping_key(after_modulo_sign)
             .map_err(|err| (err, calc_consumed(text, after_modulo_sign)))?;
         let (flags, after_flags) = parse_flags(after_mapping_key);
-        let (width, after_width) = parse_quantity(after_flags);
-        let (precision, after_precision) = parse_precision(after_width);
+        let (width, after_width) =
+            parse_quantity(after_flags).map_err(|err| (err, calc_consumed(text, after_flags)))?;
+        let (precision, after_precision) =
+            parse_precision(after_width).map_err(|err| (err, calc_consumed(text, after_width)))?;
         // A length modifier (h, l, or L) may be present,
         // but is ignored as it is not necessary for Python – so e.g. %ld is identical to %d.
         let after_length = consume_length(after_precision);

vm/src/obj/objint.rs

@@ -1,10 +1,11 @@
+use std::convert::TryFrom;
 use std::fmt;
 use std::mem::size_of;
 
 use bstr::ByteSlice;
 use num_bigint::{BigInt, BigUint, Sign};
 use num_integer::Integer;
-use num_traits::{One, Pow, Signed, ToPrimitive, Zero};
+use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
 
 use super::objbool::IntoPyBool;
 use super::objbytearray::PyByteArray;
@@ -93,20 +94,24 @@ macro_rules! impl_into_pyobject_int {
 
 impl_into_pyobject_int!(isize i8 i16 i32 i64 usize u8 u16 u32 u64 BigInt);
 
+pub fn try_to_primitive<'a, I>(i: &'a BigInt, vm: &VirtualMachine) -> PyResult<I>
+where
+    I: PrimInt + TryFrom<&'a BigInt>,
+{
+    I::try_from(i).map_err(|_| {
+        vm.new_overflow_error(format!(
+            "Python int too large to convert to Rust {}",
+            std::any::type_name::<I>()
+        ))
+    })
+}
+
 macro_rules! impl_try_from_object_int {
     ($(($t:ty, $to_prim:ident),)*) => {$(
         impl TryFromObject for $t {
             fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
                 let int = PyIntRef::try_from_object(vm, obj)?;
-                match int.value.$to_prim() {
-                    Some(value) => Ok(value),
-                    None => Err(
-                        vm.new_overflow_error(concat!(
-                            "Int value cannot fit into Rust ",
-                            stringify!($t)
-                        ).to_owned())
-                    ),
-                }
+                try_to_primitive(&int.value, vm)
             }
         }
     )*};

vm/src/obj/objiter.rs

@@ -3,9 +3,9 @@
  */
 
 use crossbeam_utils::atomic::AtomicCell;
-use num_traits::{Signed, ToPrimitive};
+use num_traits::Signed;
 
-use super::objint::PyInt;
+use super::objint::{self, PyInt};
 use super::objsequence;
 use super::objtype::{self, PyClassRef};
 use crate::exceptions::PyBaseExceptionRef;
@@ -143,9 +143,7 @@ pub fn length_hint(vm: &VirtualMachine, iter: PyObjectRef) -> PyResult<Option<us
     if result.is_negative() {
         return Err(vm.new_value_error("__length_hint__() should return >= 0".to_owned()));
     }
-    let hint = result.to_usize().ok_or_else(|| {
-        vm.new_value_error("Python int too large to convert to Rust usize".to_owned())
-    })?;
+    let hint = objint::try_to_primitive(result, vm)?;
     Ok(Some(hint))
 }
 

vm/src/stdlib/collections.rs

@@ -4,7 +4,7 @@ pub(crate) use _collections::make_module;
 mod _collections {
     use crate::common::cell::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
     use crate::function::OptionalArg;
-    use crate::obj::{objiter, objtype::PyClassRef};
+    use crate::obj::{objiter, objsequence, objtype::PyClassRef};
     use crate::pyobject::{
         IdProtocol, PyArithmaticValue::*, PyClassImpl, PyComparisonValue, PyIterable, PyObjectRef,
         PyRef, PyResult, PyValue,
@@ -247,7 +247,32 @@ mod _collections {
             self.maxlen.store(maxlen);
         }
 
-        #[pymethod(name = "__repr__")]
+        #[pymethod(magic)]
+        fn getitem(&self, idx: isize, vm: &VirtualMachine) -> PyResult {
+            let deque = self.borrow_deque();
+            objsequence::get_pos(idx, deque.len())
+                .and_then(|i| deque.get(i).cloned())
+                .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned()))
+        }
+
+        #[pymethod(magic)]
+        fn setitem(&self, idx: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mut deque = self.borrow_deque_mut();
+            objsequence::get_pos(idx, deque.len())
+                .and_then(|i| deque.get_mut(i))
+                .map(|x| *x = value)
+                .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned()))
+        }
+
+        #[pymethod(magic)]
+        fn delitem(&self, idx: isize, vm: &VirtualMachine) -> PyResult<()> {
+            let mut deque = self.borrow_deque_mut();
+            objsequence::get_pos(idx, deque.len())
+                .and_then(|i| deque.remove(i).map(drop))
+                .ok_or_else(|| vm.new_index_error("deque index out of range".to_owned()))
+        }
+
+        #[pymethod(magic)]
         fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<String> {
             let repr = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                 let elements = zelf
@@ -299,7 +324,7 @@ mod _collections {
             Ok(r)
         }
 
-        #[pymethod(name = "__eq__")]
+        #[pymethod(magic)]
         fn eq(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -312,7 +337,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__ne__")]
+        #[pymethod(magic)]
         fn ne(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -321,7 +346,7 @@ mod _collections {
             Ok(PyDeque::eq(zelf, other, vm)?.map(|v| !v))
         }
 
-        #[pymethod(name = "__lt__")]
+        #[pymethod(magic)]
         fn lt(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -334,7 +359,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__gt__")]
+        #[pymethod(magic)]
         fn gt(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -347,7 +372,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__le__")]
+        #[pymethod(magic)]
         fn le(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -360,7 +385,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__ge__")]
+        #[pymethod(magic)]
         fn ge(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -373,7 +398,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__mul__")]
+        #[pymethod(magic)]
         fn mul(&self, n: isize) -> Self {
             let deque: SimpleSeqDeque = self.borrow_deque().into();
             let mul = sequence::seq_mul(&deque, n);
@@ -389,12 +414,12 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__len__")]
+        #[pymethod(magic)]
         fn len(&self) -> usize {
             self.borrow_deque().len()
         }
 
-        #[pymethod(name = "__iter__")]
+        #[pymethod(magic)]
         fn iter(zelf: PyRef<Self>) -> PyDequeIterator {
             PyDequeIterator {
                 position: AtomicCell::new(0),
@@ -419,7 +444,7 @@ mod _collections {
 
     #[pyimpl]
     impl PyDequeIterator {
-        #[pymethod(name = "__next__")]
+        #[pymethod(magic)]
         fn next(&self, vm: &VirtualMachine) -> PyResult {
             let pos = self.position.fetch_add(1);
             let deque = self.deque.borrow_deque();
@@ -431,7 +456,7 @@ mod _collections {
             }
         }
 
-        #[pymethod(name = "__iter__")]
+        #[pymethod(magic)]
         fn iter(zelf: PyRef<Self>) -> PyRef<Self> {
             zelf
         }

vm/src/stdlib/io.rs

@@ -341,11 +341,12 @@ impl PyBytesIORef {
     //Takes an integer k (bytes) and returns them from the underlying buffer
     //If k is undefined || k == -1, then we read all bytes until the end of the file.
     //This also increments the stream position by the value of k
-    fn read(self, size: OptionalSize, vm: &VirtualMachine) -> PyResult {
-        match self.buffer(vm)?.read(size.to_usize()) {
-            Some(value) => Ok(vm.ctx.new_bytes(value)),
-            None => Err(vm.new_value_error("Error Retrieving Value".to_owned())),
-        }
+    fn read(self, size: OptionalSize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        let buf = self
+            .buffer(vm)?
+            .read(size.to_usize())
+            .unwrap_or_else(Vec::new);
+        Ok(buf)
     }
 
     //skip to the jth position
@@ -1051,9 +1052,7 @@ fn text_io_wrapper_write(
     let bytes = obj.borrow_value().to_owned().into_bytes();
 
     let len = vm.call_method(&raw, "write", vec![vm.ctx.new_bytes(bytes.clone())])?;
-    let len = objint::get_value(&len)
-        .to_usize()
-        .ok_or_else(|| vm.new_overflow_error("int to large to convert to Rust usize".to_owned()))?;
+    let len = objint::try_to_primitive(objint::get_value(&len), vm)?;
 
     // returns the count of unicode code points written
     let len = from_utf8(&bytes[..len])