Merge branch 'master' into patch-11

Author: BobTheBuidler

mypy/stubtest.py

@@ -1653,6 +1653,7 @@ def verify_typealias(
         "__loader__",
         "__spec__",
         "__annotations__",
+        "__conditional_annotations__",  # 3.14+
         "__annotate__",
         "__path__",  # mypy adds __path__ to packages, but C packages don't have it
         "__getattr__",  # resulting behaviour might be typed explicitly

mypyc/codegen/emit.py

@@ -23,7 +23,7 @@
     TYPE_PREFIX,
 )
 from mypyc.ir.class_ir import ClassIR, all_concrete_classes
-from mypyc.ir.func_ir import FuncDecl, FuncIR, get_text_signature
+from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncDecl, FuncIR, get_text_signature
 from mypyc.ir.ops import BasicBlock, Value
 from mypyc.ir.rtypes import (
     RInstance,
@@ -1222,10 +1222,11 @@ def emit_cpyfunction_instance(
         cfunc = f"(PyCFunction){cname}"
         func_flags = "METH_FASTCALL | METH_KEYWORDS"
         doc = f"PyDoc_STR({native_function_doc_initializer(fn)})"
+        has_self_arg = "true" if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD else "false"
 
         code_flags = "CO_COROUTINE"
         self.emit_line(
-            f'PyObject* {wrapper_name} = CPyFunction_New({module}, "{filepath}", "{name}", {cfunc}, {func_flags}, {doc}, {fn.line}, {code_flags});'
+            f'PyObject* {wrapper_name} = CPyFunction_New({module}, "{filepath}", "{name}", {cfunc}, {func_flags}, {doc}, {fn.line}, {code_flags}, {has_self_arg});'
         )
         self.emit_line(f"if (unlikely(!{wrapper_name}))")
         self.emit_line(error_stmt)

mypyc/irbuild/for_helpers.py

@@ -13,7 +13,6 @@
 from mypy.checkexpr import try_getting_literal
 from mypy.nodes import (
     ARG_POS,
-    BytesExpr,
     CallExpr,
     DictionaryComprehension,
     Expression,
@@ -25,10 +24,8 @@
     RefExpr,
     SetExpr,
     StarExpr,
-    StrExpr,
     TupleExpr,
     TypeAlias,
-    Var,
 )
 from mypy.types import LiteralType, TupleType, get_proper_type, get_proper_types
 from mypyc.ir.ops import (
@@ -69,6 +66,7 @@
     short_int_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder
+from mypyc.irbuild.constant_fold import constant_fold_expr
 from mypyc.irbuild.prepare import GENERATOR_HELPER_NAME
 from mypyc.irbuild.targets import AssignmentTarget, AssignmentTargetTuple
 from mypyc.primitives.dict_ops import (
@@ -1227,8 +1225,9 @@ def gen_cleanup(self) -> None:
 
 
 def get_expr_length(builder: IRBuilder, expr: Expression) -> int | None:
-    if isinstance(expr, (StrExpr, BytesExpr)):
-        return len(expr.value)
+    folded = constant_fold_expr(builder, expr)
+    if isinstance(folded, (str, bytes)):
+        return len(folded)
     elif isinstance(expr, (ListExpr, TupleExpr)):
         # if there are no star expressions, or we know the length of them,
         # we know the length of the expression
@@ -1238,14 +1237,6 @@ def get_expr_length(builder: IRBuilder, expr: Expression) -> int | None:
             return other + sum(stars)  # type: ignore [arg-type]
     elif isinstance(expr, StarExpr):
         return get_expr_length(builder, expr.expr)
-    elif (
-        isinstance(expr, RefExpr)
-        and isinstance(expr.node, Var)
-        and expr.node.is_final
-        and isinstance(expr.node.final_value, str)
-        and expr.node.has_explicit_value
-    ):
-        return len(expr.node.final_value)
     # TODO: extend this, passing length of listcomp and genexp should have worthwhile
     # performance boost and can be (sometimes) figured out pretty easily. set and dict
     # comps *can* be done as well but will need special logic to consider the possibility

mypyc/lib-rt/CPy.h

@@ -971,7 +971,7 @@ typedef struct {
 
 PyObject* CPyFunction_New(PyObject *module, const char *filename, const char *funcname,
                           PyCFunction func, int func_flags, const char *func_doc,
-                          int first_line, int code_flags);
+                          int first_line, int code_flags, bool has_self_arg);
 PyObject* CPyFunction_get_name(PyObject *op, void *context);
 int CPyFunction_set_name(PyObject *op, PyObject *value, void *context);
 PyObject* CPyFunction_get_code(PyObject *op, void *context);

mypyc/lib-rt/function_wrapper.c

@@ -177,16 +177,21 @@ static PyObject* CPyFunction_Vectorcall(PyObject *func, PyObject *const *args, s
     PyCFunction meth = ((PyCFunctionObject *)f)->m_ml->ml_meth;
 
     self = ((PyCFunctionObject *)f)->m_self;
+    if (!self) {
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+    }
     return ((_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames);
 }
 
 
 static CPyFunction* CPyFunction_Init(CPyFunction *op, PyMethodDef *ml, PyObject* name,
-                                     PyObject *module, PyObject* code) {
+                                     PyObject *module, PyObject* code, bool set_self) {
     PyCFunctionObject *cf = (PyCFunctionObject *)op;
     CPyFunction_weakreflist(op) = NULL;
     cf->m_ml = ml;
-    cf->m_self = (PyObject *) op;
+    cf->m_self = set_self ? (PyObject *) op : NULL;
 
     Py_XINCREF(module);
     cf->m_module = module;
@@ -226,9 +231,10 @@ static PyMethodDef* CPyMethodDef_New(const char *name, PyCFunction func, int fla
 
 PyObject* CPyFunction_New(PyObject *module, const char *filename, const char *funcname,
                           PyCFunction func, int func_flags, const char *func_doc,
-                          int first_line, int code_flags) {
+                          int first_line, int code_flags, bool has_self_arg) {
     PyMethodDef *method = NULL;
     PyObject *code = NULL, *op = NULL;
+    bool set_self = false;
 
     if (!CPyFunctionType) {
         CPyFunctionType = (PyTypeObject *)PyType_FromSpec(&CPyFunction_spec);
@@ -245,8 +251,15 @@ PyObject* CPyFunction_New(PyObject *module, const char *filename, const char *fu
     if (unlikely(!code)) {
         goto err;
     }
+
+    // Set m_self inside the function wrapper only if the wrapped function has no self arg
+    // to pass m_self as the self arg when the function is called.
+    // When the function has a self arg, it will come in the args vector passed to the
+    // vectorcall handler.
+    set_self = !has_self_arg;
     op = (PyObject *)CPyFunction_Init(PyObject_GC_New(CPyFunction, CPyFunctionType),
-                                      method, PyUnicode_FromString(funcname), module, code);
+                                      method, PyUnicode_FromString(funcname), module,
+                                      code, set_self);
     if (unlikely(!op)) {
         goto err;
     }

mypyc/test-data/irbuild-tuple.test

@@ -434,6 +434,54 @@ L4:
     a = r1
     return 1
 
+[case testTupleBuiltFromConstantFolding]
+from typing import Final
+
+c: Final = "c"
+
+def f2(val: str) -> str:
+    return val + "f2"
+
+def test() -> None:
+    # `"ab" + c` should constant fold to "abc"
+    a = tuple(f2(x) for x in "ab" + c)
+
+[out]
+def f2(val):
+    val, r0, r1 :: str
+L0:
+    r0 = 'f2'
+    r1 = PyUnicode_Concat(val, r0)
+    return r1
+def test():
+    r0 :: str
+    r1 :: tuple
+    r2 :: native_int
+    r3 :: bit
+    r4, x, r5 :: str
+    r6 :: native_int
+    a :: tuple
+L0:
+    r0 = 'abc'
+    r1 = PyTuple_New(3)
+    r2 = 0
+    goto L2
+L1:
+    r3 = r2 < 3 :: signed
+    if r3 goto L2 else goto L4 :: bool
+L2:
+    r4 = CPyStr_GetItemUnsafe(r0, r2)
+    x = r4
+    r5 = f2(x)
+    CPySequenceTuple_SetItemUnsafe(r1, r2, r5)
+L3:
+    r6 = r2 + 1
+    r2 = r6
+    goto L1
+L4:
+    a = r1
+    return 1
+
 [case testTupleBuiltFromFinalStr]
 from typing import Final
 

mypyc/test-data/run-async.test

@@ -228,6 +228,7 @@ async def sleep(t: float) -> None: ...
 
 [case testAsyncWith]
 from testutil import async_val
+from typing import Any
 
 class async_ctx:
     async def __aenter__(self) -> str:
@@ -242,15 +243,22 @@ async def async_with() -> str:
     async with async_ctx() as x:
         return await async_val("body")
 
+async def async_with_vectorcall() -> str:
+    ctx: Any = async_ctx()
+    async with ctx:
+        return await async_val("vc")
 
 [file driver.py]
-from native import async_with
+from native import async_with, async_with_vectorcall
 from testutil import run_generator
 
 yields, val = run_generator(async_with(), [None, 'x', None])
 assert yields == ('enter', 'body', 'exit'), yields
 assert val == 'x', val
 
+yields, val = run_generator(async_with_vectorcall(), [None, 'x', None])
+assert yields == ('enter', 'vc', 'exit'), yields
+assert val == 'x', val
 
 [case testAsyncReturn]
 from testutil import async_val
@@ -1516,7 +1524,9 @@ def test_method() -> None:
     assert str(T.returns_one_async).startswith("<function T.returns_one_async"), str(T.returns_one_async)
 
     t = T()
-    assert asyncio.run(t.returns_one_async()) == 1
+    # Call through variable to make sure the call is through vectorcall and not optimized to a native call.
+    f: Any = t.returns_one_async
+    assert asyncio.run(f()) == 1
 
     assert not is_coroutine(T.returns_two)
     assert is_coroutine(T.returns_two_async)

test-data/unit/check-incremental.test

@@ -2336,7 +2336,6 @@ tmp/c.py:1: error: Module "d" has no attribute "x"
 [out]
 [out2]
 mypy: can't read file 'tmp/nonexistent.py': No such file or directory
--- '
 
 [case testSerializeAbstractPropertyIncremental]
 from abc import abstractmethod

test-data/unit/cmdline.test

@@ -117,7 +117,6 @@ sub.pkg is not a valid Python package name
 mypy: can't decode file 'a.py': unknown encoding: uft-8
 == Return code: 2
 
--- '
 [case testCannotIgnoreDuplicateModule]
 # cmd: mypy one/mod/__init__.py two/mod/__init__.py
 [file one/mod/__init__.py]
@@ -546,7 +545,6 @@ a/b/c/d/e/__init__.py:3: error: Argument 1 to "g" has incompatible type "None";
 [out]
 mypy: can't read file 'nope.py': No such file or directory
 == Return code: 2
---'
 
 [case testModulesAndPackages]
 # cmd: mypy --package p.a --package p.b --module c