[mypyc] Add str.isalnum() primitive (#20852)

Added `str.isalnum()` similar to `str.isspace()`.

One interesting thing to point out here is that the benchmarks decline
in speed relative to the string's length:

| All-alphanumeric | mypyc (s) | Python (s) | Speedup |
  |--------|----------:|------------:|--------:|         
| length 1 (`'a'`) | 0.645 | 2.036 | 3.16x |
| length 10 (`'abcde12345'`) | 1.026 | 2.607 | 2.54x |
| length 100 (`'a' * 100`) | 3.599 | 7.848 | 2.18x |
| length 1 (UCS-2: U+00E9 `é`) | 0.816 | 1.976 | 2.42x |
  | length 10 (UCS-2: U+00E9 * 10) | 2.091 | 2.587 | 1.24x |
  | length 100 (UCS-2: U+00E9 * 100) | 14.298 | 7.814 | 0.55x |


<br />


  | Non-alphanumeric (early exit) | mypyc (s) | Python (s) | Speedup |
  |--------|----------:|------------:|--------:|
  | length 1 (`' '`) | 0.622 | 2.006 | 3.22x |
  | length 100 (`'!' * 100`) | 0.617 | 2.024 | 3.28x |
  | length 100 (`'a' * 99 + '!'`) | 3.453 | 10.246 | 2.97x |


<br />

Not entirely sure how to interpret this but could it be because the
[Py_UNICODE_ISALNUM](https://github.com/python/cpython/blob/175ab31377d9e616efb95168099d8c2c9036504a/Include/cpython/unicodeobject.h#L769)
calls 4 functions internally which is more optimized in CPython due to
PGO & LTO (?)

Author: VaggelisD

mypyc/doc/str_operations.rst

@@ -38,6 +38,8 @@ Methods
 * ``s1.find(s2: str)``
 * ``s1.find(s2: str, start: int)``
 * ``s1.find(s2: str, start: int, end: int)``
+* ``s.isspace()``
+* ``s.isalnum()``
 * ``s.join(x: Iterable)``
 * ``s.lstrip()``
 * ``s.lstrip(chars: str)``

mypyc/lib-rt/CPy.h

@@ -781,6 +781,7 @@ Py_ssize_t CPyStr_CountFull(PyObject *unicode, PyObject *substring, CPyTagged st
 CPyTagged CPyStr_Ord(PyObject *obj);
 PyObject *CPyStr_Multiply(PyObject *str, CPyTagged count);
 bool CPyStr_IsSpace(PyObject *str);
+bool CPyStr_IsAlnum(PyObject *str);
 
 // Bytes operations
 

mypyc/lib-rt/str_ops.c

@@ -654,3 +654,26 @@ bool CPyStr_IsSpace(PyObject *str) {
     }
     return true;
 }
+
+bool CPyStr_IsAlnum(PyObject *str) {
+    Py_ssize_t len = PyUnicode_GET_LENGTH(str);
+    if (len == 0) return false;
+
+    if (PyUnicode_IS_ASCII(str)) {
+        const Py_UCS1 *data = PyUnicode_1BYTE_DATA(str);
+        for (Py_ssize_t i = 0; i < len; i++) {
+            if (!Py_ISALNUM(data[i]))
+                return false;
+        }
+        return true;
+    }
+
+    int kind = PyUnicode_KIND(str);
+    const void *data = PyUnicode_DATA(str);
+    for (Py_ssize_t i = 0; i < len; i++) {
+        Py_UCS4 ch = PyUnicode_READ(kind, data, i);
+        if (!Py_UNICODE_ISALNUM(ch))
+            return false;
+    }
+    return true;
+}

mypyc/primitives/str_ops.py

@@ -405,6 +405,15 @@
     error_kind=ERR_NEVER,
 )
 
+method_op(
+    name="isalnum",
+    arg_types=[str_rprimitive],
+    return_type=bool_rprimitive,
+    c_function_name="CPyStr_IsAlnum",
+    error_kind=ERR_NEVER,
+)
+
+
 # obj.decode()
 method_op(
     name="decode",

mypyc/test-data/fixtures/ir.py

@@ -132,6 +132,7 @@ def removesuffix(self, suffix: str, /) -> str: ...
     def islower(self) -> bool: ...
     def count(self, substr: str, start: Optional[int] = None, end: Optional[int] = None) -> int: pass
     def isspace(self) -> bool: ...
+    def isalnum(self) -> bool: ...
 
 class float:
     def __init__(self, x: object) -> None: pass

mypyc/test-data/irbuild-str.test

@@ -983,3 +983,14 @@ def is_space(x):
 L0:
     r0 = CPyStr_IsSpace(x)
     return r0
+
+[case testStrIsAlnum]
+def is_alnum(x: str) -> bool:
+    return x.isalnum()
+[out]
+def is_alnum(x):
+    x :: str
+    r0 :: bool
+L0:
+    r0 = CPyStr_IsAlnum(x)
+    return r0

mypyc/test-data/run-strings.test

@@ -1269,3 +1269,33 @@ def test_isspace() -> None:
         c = chr(i)
         a: Any = c
         assert c.isspace() == a.isspace()
+
+[case testIsAlnum]
+def test_isalnum_basic() -> None:
+    assert "abc".isalnum()
+    assert "ABC".isalnum()
+    assert "abc123".isalnum()
+    assert "123".isalnum()
+    assert not "".isalnum()
+    assert not " ".isalnum()
+    assert not "abc!".isalnum()
+    assert not "hello world".isalnum()
+    assert not "abc-123".isalnum()
+
+def test_isalnum_unicode() -> None:
+    # Single chars: letters and digits from various scripts
+    assert "\u00E9".isalnum()        # é  (UCS-1 Latin letter)
+    assert "\u0660".isalnum()        # ٠  (UCS-2 Arabic-Indic digit)
+    assert "\u4E2D".isalnum()        # 中 (UCS-2 CJK ideograph)
+    assert "\U00010400".isalnum()    # 𐐀 (UCS-4 Deseret capital letter long I)
+    assert not "\u2000".isalnum()    # EN QUAD (whitespace)
+    assert not "\u0021".isalnum()    # !
+    assert not "\u00B6".isalnum()    # ¶  (pilcrow sign, punctuation)
+
+    # Mixed Unicode letters and digits — all alnum
+    assert "\u00E9\u0660".isalnum()         # é٠
+    assert "\u4E2D\u0041\u0660".isalnum()   # 中A٠
+
+    # Unicode letter/digit mixed with punctuation — not alnum
+    assert not "\u00E9!".isalnum()
+    assert not "\u4E2D\u2000".isalnum()     # CJK + whitespace