Eliminate data copy when calling str() on a bytes-like object (#963)

* Eliminate data copy when calling str() on a bytes-like object

* Update after review

Author: BCSharp

Src/IronPython/Runtime/ByteArray.cs

@@ -15,6 +15,7 @@
 using Microsoft.Scripting.Runtime;
 using Microsoft.Scripting.Utils;
 
+using IronPython.Runtime.Exceptions;
 using IronPython.Runtime.Operations;
 using IronPython.Runtime.Types;
 
@@ -1078,6 +1079,13 @@ private string Repr() {
             }
         }
 
+        public virtual string __str__(CodeContext context) {
+            if (context.LanguageContext.PythonOptions.BytesWarning) {
+                PythonOps.Warn(context, PythonExceptions.BytesWarning, "str() on a bytearray instance");
+            }
+            return Repr();
+        }
+
         public virtual string __repr__(CodeContext context) => Repr();
 
         public override string ToString() => Repr();

Src/IronPython/Runtime/Bytes.cs

@@ -16,6 +16,7 @@
 using Microsoft.Scripting.Runtime;
 using Microsoft.Scripting.Utils;
 
+using IronPython.Runtime.Exceptions;
 using IronPython.Runtime.Operations;
 using IronPython.Runtime.Types;
 using NotNullWhenAttribute = System.Diagnostics.CodeAnalysis.NotNullWhenAttribute;
@@ -854,6 +855,13 @@ public PythonTuple __reduce__(CodeContext context) {
             );
         }
 
+        public virtual string __str__(CodeContext context) {
+            if (context.LanguageContext.PythonOptions.BytesWarning) {
+                PythonOps.Warn(context, PythonExceptions.BytesWarning, "str() on a bytes instance");
+            }
+            return _bytes.BytesRepr();
+        }
+
         public virtual string __repr__(CodeContext context) {
             return _bytes.BytesRepr();
         }

Src/IronPython/Runtime/Operations/StringOps.cs

@@ -162,7 +162,6 @@ internal static object FastNew(CodeContext/*!*/ context, object? x) {
                 return "None";
             }
             if (x is string) {
-                // check ascii
                 return x;
             }
 
@@ -287,10 +286,13 @@ public static object __new__(CodeContext/*!*/ context, [NotNull]PythonType cls,
         }
 
         [StaticExtensionMethod]
-        public static object __new__(CodeContext/*!*/ context, [NotNull]PythonType cls, [BytesLike, NotNull]IList<byte> @object, [NotNull]string encoding, [NotNull]string errors = "strict") {
+        public static object __new__(CodeContext/*!*/ context, [NotNull]PythonType cls, [NotNull]IBufferProtocol @object, [NotNull]string encoding, [NotNull]string errors = "strict") {
             if (cls == TypeCache.String) {
-                if (@object is Bytes) return ((Bytes)@object).decode(context, encoding, errors);
-                return new Bytes(@object).decode(context, encoding, errors);
+                try {
+                    return RawDecode(context, @object, encoding, errors);
+                } catch (BufferException) {
+                    throw PythonOps.TypeErrorForBadInstance("decoding to str: need a bytes-like object, {0} found", @object);
+                }
             } else {
                 return cls.CreateInstance(context, __new__(context, TypeCache.String, @object, encoding, errors));
             }

Tests/test_bytes.py

@@ -7,6 +7,7 @@
 import itertools
 import sys
 import unittest
+import warnings
 
 from iptest import IronPythonTestCase, is_cli, is_cpython, long, run_test, skipUnlessIronPython
 
@@ -299,6 +300,40 @@ def __index__(self):
         self.assertRaises(TypeError, int.from_bytes, IndexableInt(2), 'big')
         self.assertRaises(TypeError, int.from_bytes, 2, 'big')
 
+    @unittest.skipUnless(sys.flags.bytes_warning, "Run Python with the '-b' flag on command line for this test")
+    def test_byteswarning(self):
+        with warnings.catch_warnings(record=True) as ws:
+            warnings.simplefilter("always")
+
+            with self.assertWarnsRegex(BytesWarning, r"^str\(\) on a bytes instance$"):
+                self.assertEqual(str(b'abc'), "b'abc'")
+            self.assertEqual(str(b'abc', 'ascii'), 'abc')
+
+            with self.assertWarnsRegex(BytesWarning, r"^str\(\) on a bytearray instance$"):
+                self.assertEqual(str(bytearray(b'abc')), "bytearray(b'abc')")
+            self.assertEqual(str(bytearray(b'abc'), 'ascii'), 'abc')
+
+            class B(bytes):
+                def __str__(self):
+                    return "This is B"
+
+            self.assertEqual(str(B(b'abc')), "This is B") # no warning
+
+            class B2(bytes): pass
+            with self.assertWarnsRegex(BytesWarning, r"^str\(\) on a bytes instance$"):
+                self.assertEqual(str(B2(b'abc')), "b'abc'")
+
+        self.assertEqual(len(ws), 0) # no unchecked warnings
+
+    def test_byteswarning_user(self):
+        with warnings.catch_warnings(record=True) as ws:
+            warnings.simplefilter("always")
+
+            with self.assertWarnsRegex(BytesWarning, r"^test warning$"):
+                warnings.warn("test warning", BytesWarning)
+
+        self.assertEqual(len(ws), 0) # no unchecked warnings
+
     def test_capitalize(self):
         tests = [(b'foo', b'Foo'),
                 (b' foo', b' foo'),

Tests/test_str.py

@@ -6,6 +6,7 @@
 import os
 import sys
 import unittest
+import warnings
 
 from iptest import IronPythonTestCase, is_cli, run_test, skipUnlessIronPython
 
@@ -54,6 +55,14 @@ def test_constructor(self):
         if is_cli:
             self.assertEqual('ä', str('ä'.Chars[0])) # StringOps.__new__(..., char)
 
+        self.assertRegex(str(memoryview(b'abc')), r"^<memory at .+>$")
+        self.assertEqual(str(memoryview(b'abc'), 'ascii'), 'abc')
+        self.assertRaises(TypeError, str, memoryview(b'abc')[::2], 'ascii')
+
+        import array
+        self.assertEqual(str(array.array('B', b'abc')), "array('B', [97, 98, 99])")
+        self.assertEqual(str(array.array('B', b'abc'), 'ascii'), 'abc')
+
     def test_add_mul(self):
         self.assertRaises(TypeError, lambda: "a" + 3)
         self.assertRaises(TypeError, lambda: 3 + "a")