Merge branch 'master' into bytes-get-item

# Conflicts:
#	mypyc/irbuild/specialize.py

Author: JukkaL

mypyc/codegen/emit.py

@@ -33,6 +33,7 @@
     RUnion,
     int_rprimitive,
     is_bool_or_bit_rprimitive,
+    is_bytearray_rprimitive,
     is_bytes_rprimitive,
     is_dict_rprimitive,
     is_fixed_width_rtype,
@@ -664,6 +665,16 @@ def emit_cast(
             self.emit_lines(f"    {dest} = {src};", "else {")
             self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
             self.emit_line("}")
+        elif is_bytearray_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            check = "(PyByteArray_Check({}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(src, src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
         elif is_tuple_rprimitive(typ):
             if declare_dest:
                 self.emit_line(f"{self.ctype(typ)} {dest};")

mypyc/doc/bytearray_operations.rst

@@ -0,0 +1,13 @@
+.. _bytearray-ops:
+
+Native bytearray operations
+============================
+
+These ``bytearray`` operations have fast, optimized implementations. Other
+bytearray operations use generic implementations that are often slower.
+
+Construction
+------------
+
+* ``bytearray()``
+* ``bytearray(x)``

mypyc/doc/index.rst

@@ -37,6 +37,7 @@ generate fast code.
    float_operations
    str_operations
    bytes_operations
+   bytearray_operations
    list_operations
    dict_operations
    set_operations

mypyc/doc/using_type_annotations.rst

@@ -37,11 +37,14 @@ implementations:
 * ``float`` (:ref:`native operations <float-ops>`)
 * ``bool`` (:ref:`native operations <bool-ops>`)
 * ``str`` (:ref:`native operations <str-ops>`)
+* ``bytes`` (:ref:`native operations <bytes-ops>`)
+* ``bytearray`` (:ref:`native operations <bytearray-ops>`)
 * ``list[T]`` (:ref:`native operations <list-ops>`)
 * ``dict[K, V]`` (:ref:`native operations <dict-ops>`)
 * ``set[T]`` (:ref:`native operations <set-ops>`)
 * ``tuple[T, ...]`` (variable-length tuple; :ref:`native operations <tuple-ops>`)
 * ``None``
+* ``range``
 
 The link after each type lists all supported native, optimized
 operations for the type. You can use all operations supported by

mypyc/ir/deps.py

@@ -51,3 +51,4 @@ def get_header(self) -> str:
 
 BYTES_EXTRA_OPS: Final = SourceDep("bytes_extra_ops.c")
 BYTES_WRITER_EXTRA_OPS: Final = SourceDep("byteswriter_extra_ops.c")
+BYTEARRAY_EXTRA_OPS: Final = SourceDep("bytearray_extra_ops.c")

mypyc/ir/rtypes.py

@@ -504,6 +504,11 @@ def __hash__(self) -> int:
 # Python bytes object.
 bytes_rprimitive: Final = RPrimitive("builtins.bytes", is_unboxed=False, is_refcounted=True)
 
+# Python bytearray object.
+bytearray_rprimitive: Final = RPrimitive(
+    "builtins.bytearray", is_unboxed=False, is_refcounted=True
+)
+
 # Tuple of an arbitrary length (corresponds to Tuple[t, ...], with
 # explicit '...').
 tuple_rprimitive: Final = RPrimitive("builtins.tuple", is_unboxed=False, is_refcounted=True)
@@ -632,6 +637,10 @@ def is_bytes_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
     return isinstance(rtype, RPrimitive) and rtype.name == "builtins.bytes"
 
 
+def is_bytearray_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.bytearray"
+
+
 def is_tuple_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
     return isinstance(rtype, RPrimitive) and rtype.name == "builtins.tuple"
 
@@ -646,6 +655,7 @@ def is_sequence_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
         or is_tuple_rprimitive(rtype)
         or is_str_rprimitive(rtype)
         or is_bytes_rprimitive(rtype)
+        or is_bytearray_rprimitive(rtype)
     )
 
 

mypyc/irbuild/mapper.py

@@ -31,6 +31,7 @@
     RType,
     RUnion,
     bool_rprimitive,
+    bytearray_rprimitive,
     bytes_rprimitive,
     dict_rprimitive,
     float_rprimitive,
@@ -88,6 +89,8 @@ def type_to_rtype(self, typ: Type | None) -> RType:
                 return str_rprimitive
             elif typ.type.fullname == "builtins.bytes":
                 return bytes_rprimitive
+            elif typ.type.fullname == "builtins.bytearray":
+                return bytearray_rprimitive
             elif typ.type.fullname == "builtins.list":
                 return list_rprimitive
             # Dict subclasses are at least somewhat common and we

mypyc/irbuild/specialize.py

@@ -94,11 +94,11 @@
     join_formatted_strings,
     tokenizer_format_call,
 )
+from mypyc.primitives.bytearray_ops import isinstance_bytearray
 from mypyc.primitives.bytes_ops import (
     bytes_adjust_index_op,
     bytes_get_item_unsafe_op,
     bytes_range_check_op,
-    isinstance_bytearray,
     isinstance_bytes,
 )
 from mypyc.primitives.dict_ops import (

mypyc/lib-rt/bytearray_extra_ops.c

@@ -0,0 +1,5 @@
+#include "bytearray_extra_ops.h"
+
+PyObject *CPyByteArray_New(void) {
+    return PyByteArray_FromStringAndSize(NULL, 0);
+}

mypyc/lib-rt/bytearray_extra_ops.h

@@ -0,0 +1,10 @@
+#ifndef MYPYC_BYTEARRAY_EXTRA_OPS_H
+#define MYPYC_BYTEARRAY_EXTRA_OPS_H
+
+#include <Python.h>
+#include "CPy.h"
+
+// Construct empty bytearray
+PyObject *CPyByteArray_New(void);
+
+#endif