[mypyc] feat: use get_expr_length_value in translate_len (#20074)

Currently, `translate_len` can determine the length of an RTuple at
compile time

This PR extends this capability to all expressions supported by
`get_expr_length_value`

This will constant fold the code example displayed in
mypyc/mypyc#1152 without waiting for the
implementation of #19886 which has a few steps ahead of it

Before:
```python
def extend_and_specialize(items: list[dict[str, Any]]) -> None:
    types: Final[dict[str, Any]] = {i["name"]: i for i in items}
    types.update(
        {
            k[len("https://w3id.org/cwl/salad#") :]: v
            for k, v in types.items()
            if k.startswith("https://w3id.org/cwl/salad#")
        }
    )
```

After:
```python
def extend_and_specialize(items: list[dict[str, Any]]) -> None:
    types: Final[dict[str, Any]] = {i["name"]: i for i in items}
    types.update(
        {
            k[27 : ]: v
            for k, v in types.items()
            if k.startswith("https://w3id.org/cwl/salad#")
        }
    )
```

Even after #19986, this will also work for some situations that constant
folding cannot handle but `get_expr_length` can.

Author: BobTheBuidler

mypyc/irbuild/specialize.py

@@ -70,6 +70,7 @@
     is_int64_rprimitive,
     is_int_rprimitive,
     is_list_rprimitive,
+    is_sequence_rprimitive,
     is_uint8_rprimitive,
     list_rprimitive,
     object_rprimitive,
@@ -81,6 +82,7 @@
 from mypyc.irbuild.constant_fold import constant_fold_expr
 from mypyc.irbuild.for_helpers import (
     comprehension_helper,
+    get_expr_length_value,
     sequence_from_generator_preallocate_helper,
     translate_list_comprehension,
     translate_set_comprehension,
@@ -222,17 +224,11 @@ def translate_len(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     if len(expr.args) == 1 and expr.arg_kinds == [ARG_POS]:
         arg = expr.args[0]
         expr_rtype = builder.node_type(arg)
-        if isinstance(expr_rtype, RTuple):
-            # len() of fixed-length tuple can be trivially determined
-            # statically, though we still need to evaluate it.
-            builder.accept(arg)
-            return Integer(len(expr_rtype.types))
+        # NOTE (?) I'm not sure if my handling of can_borrow is correct here
+        obj = builder.accept(arg, can_borrow=is_list_rprimitive(expr_rtype))
+        if is_sequence_rprimitive(expr_rtype) or isinstance(expr_rtype, RTuple):
+            return get_expr_length_value(builder, arg, obj, expr.line, use_pyssize_t=False)
         else:
-            if is_list_rprimitive(builder.node_type(arg)):
-                borrow = True
-            else:
-                borrow = False
-            obj = builder.accept(arg, can_borrow=borrow)
             return builder.builtin_len(obj, expr.line)
     return None
 

mypyc/test-data/irbuild-basic.test

@@ -3799,3 +3799,13 @@ L0:
     r2.__mypyc_env__ = r0; r3 = is_error
     wrapper = r2
     return wrapper
+
+[case testStaticLength]
+def get_length() -> int:
+    return len("https://w3id.org/cwl/salad#")
+[out]
+def get_length():
+    r0 :: str
+L0:
+    r0 = 'https://w3id.org/cwl/salad#'
+    return 54