Make common::repr throw error instead of panic (RustPython#4520)

Author: minhrongcon2000

common/src/bytes.rs

@@ -1,8 +1,10 @@
-pub fn repr(b: &[u8]) -> String {
+use crate::str::ReprOverflowError;
+
+pub fn repr(b: &[u8]) -> Result<String, ReprOverflowError> {
     repr_with(b, &[], "")
 }
 
-pub fn repr_with(b: &[u8], prefixes: &[&str], suffix: &str) -> String {
+pub fn repr_with(b: &[u8], prefixes: &[&str], suffix: &str) -> Result<String, ReprOverflowError> {
     use std::fmt::Write;
 
     let mut out_len = 0usize;
@@ -23,8 +25,7 @@ pub fn repr_with(b: &[u8], prefixes: &[&str], suffix: &str) -> String {
             0x20..=0x7e => 1,
             _ => 4, // \xHH
         };
-        // TODO: OverflowError
-        out_len = out_len.checked_add(incr).unwrap();
+        out_len = out_len.checked_add(incr).ok_or(ReprOverflowError)?;
     }
 
     let (quote, num_escaped_quotes) = crate::str::choose_quotes_for_repr(squote, dquote);
@@ -57,5 +58,5 @@ pub fn repr_with(b: &[u8], prefixes: &[&str], suffix: &str) -> String {
     res.push(quote);
     res.push_str(suffix);
 
-    res
+    Ok(res)
 }

compiler/ast/src/constant.rs

@@ -1,3 +1,5 @@
+use std::fmt::Error;
+
 use num_bigint::BigInt;
 pub use rustpython_compiler_core::ConversionFlag;
 
@@ -42,7 +44,7 @@ impl std::fmt::Display for Constant {
             Constant::None => f.pad("None"),
             Constant::Bool(b) => f.pad(if *b { "True" } else { "False" }),
             Constant::Str(s) => rustpython_common::str::repr(s).fmt(f),
-            Constant::Bytes(b) => f.pad(&rustpython_common::bytes::repr(b)),
+            Constant::Bytes(b) => f.pad(&rustpython_common::bytes::repr(b).map_err(|_err| Error)?),
             Constant::Int(i) => i.fmt(f),
             Constant::Tuple(tup) => {
                 if let [elt] = &**tup {

vm/src/builtins/bytearray.rs

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

vm/src/builtins/bytes.rs

@@ -116,8 +116,8 @@ impl PyBytes {
 )]
 impl PyBytes {
     #[pymethod(magic)]
-    pub(crate) fn repr(&self) -> String {
-        self.inner.repr(None)
+    pub(crate) fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
+        self.inner.repr(None, vm)
     }
 
     #[pymethod(magic)]

vm/src/bytesinner.rs

@@ -5,6 +5,7 @@ use crate::{
     },
     byte::bytes_from_object,
     cformat::cformat_bytes,
+    convert::ToPyException,
     function::{ArgIterable, Either, OptionalArg, OptionalOption, PyComparisonValue},
     identifier,
     protocol::PyBuffer,
@@ -246,12 +247,13 @@ impl PyBytesInner {
         &self.elements
     }
 
-    pub fn repr(&self, class_name: Option<&str>) -> String {
-        if let Some(class_name) = class_name {
+    pub fn repr(&self, class_name: Option<&str>, vm: &VirtualMachine) -> PyResult<String> {
+        let repr = if let Some(class_name) = class_name {
             rustpython_common::bytes::repr_with(&self.elements, &[class_name, "("], ")")
         } else {
             rustpython_common::bytes::repr(&self.elements)
-        }
+        };
+        repr.map_err(|err| err.to_pyexception(vm))
     }
 
     #[inline]

vm/src/exceptions.rs

@@ -1,6 +1,7 @@
 use self::types::{PyBaseException, PyBaseExceptionRef};
 use crate::builtins::tuple::IntoPyTuple;
 use crate::common::lock::PyRwLock;
+use crate::common::str::ReprOverflowError;
 use crate::{
     builtins::{
         traceback::PyTracebackRef, PyNone, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
@@ -1621,3 +1622,9 @@ pub(super) mod types {
         "Base class for warnings about encodings."
     }
 }
+
+impl ToPyException for ReprOverflowError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        vm.new_overflow_error(self.to_string())
+    }
+}