resolve: bytes-related issue

Karatuss · Karatuss · commit ee890ad1328f · 2022-08-29T17:47:31.000+09:00
diff --git a/vm/src/vm/vm_ops.rs b/vm/src/vm/vm_ops.rs
@@ -1,5 +1,3 @@
-use num_traits::ToPrimitive;
-
 use super::{PyMethod, VirtualMachine};
 use crate::{
     builtins::{PyInt, PyIntRef, PyStrInterned},
@@ -8,6 +6,7 @@ use crate::{
     protocol::{PyIterReturn, PyNumberMethodsOffset, PySequence},
     types::PyComparisonOp,
 };
+use num_traits::ToPrimitive;
 
 /// Collection of operators
 impl VirtualMachine {
@@ -281,15 +280,34 @@ impl VirtualMachine {
                 let seq_a = PySequence::new(a, self);
                 let seq_b = PySequence::new(b, self);
 
+                // TODO: remove the duplicated conditions
+                // The reason I don't put the below sepecial condition into `PyBytes::AsSequence::repeat` is
+                // we cannot use `to_owned()` in `PyBytes::repeat`.
                 if let Some(seq_a) = seq_a {
-                    let n = b.try_int(self)?.as_bigint().to_usize().ok_or_else(|| {
+                    let n = b.try_int(self)?.as_bigint().to_isize().ok_or_else(|| {
                         self.new_overflow_error("repeated bytes are too long".to_owned())
                     })?;
+
+                    if n == 1 && a.class().is(self.ctx.types.bytes_type) {
+                        // Special case: when some `bytes` is multiplied by `1`,
+                        // nothing really happens, we need to return an object itself
+                        // with the same `id()` to be compatible with CPython.
+                        // This only works for `bytes` itself, not its subclasses.
+                        return Ok(a.to_owned());
+                    }
                     return seq_a.repeat(n, self);
                 } else if let Some(seq_b) = seq_b {
-                    let n = a.try_int(self)?.as_bigint().to_usize().ok_or_else(|| {
+                    let n = a.try_int(self)?.as_bigint().to_isize().ok_or_else(|| {
                         self.new_overflow_error("repeated bytes are too long".to_owned())
                     })?;
+
+                    if n == 1 && b.class().is(self.ctx.types.bytes_type) {
+                        // Special case: when some `bytes` is multiplied by `1`,
+                        // nothing really happens, we need to return an object itself
+                        // with the same `id()` to be compatible with CPython.
+                        // This only works for `bytes` itself, not its subclasses.
+                        return Ok(b.to_owned());
+                    }
                     return seq_b.repeat(n, self);
                 }
                 return Ok(self.ctx.not_implemented());
