mypy-dev 2.4.0a1__tar.gz → 2.4.0a2__tar.gz

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mypy-dev
-Version: 2.4.0a1
+Version: 2.4.0a2
 Summary: Optional static typing for Python
 Author-email: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
 License-Expression: MIT
@@ -28,8 +28,8 @@ Requires-Dist: typing_extensions>=4.14.0; python_version >= "3.15"
 Requires-Dist: mypy_extensions>=1.0.0
 Requires-Dist: pathspec>=1.0.0
 Requires-Dist: tomli>=1.1.0; python_version < "3.11"
-Requires-Dist: librt>=0.13.0; platform_python_implementation != "PyPy"
-Requires-Dist: ast-serialize<1.0.0,>=0.6.0
+Requires-Dist: librt>=0.15.0; platform_python_implementation != "PyPy"
+Requires-Dist: ast-serialize<1.0.0,>=0.8.0
 Provides-Extra: dmypy
 Requires-Dist: psutil>=4.0; extra == "dmypy"
 Provides-Extra: mypyc

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/cache.py

@@ -48,7 +48,10 @@ bump CACHE_VERSION below.
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any, Final, TypeAlias as _TypeAlias
+from typing import TYPE_CHECKING, Any, Final, TypeAlias as _TypeAlias
+
+if TYPE_CHECKING:
+    from mypy.types import SentinelValue
 
 from librt.internal import (
     ReadBuffer as ReadBuffer,
@@ -69,7 +72,7 @@ from librt.internal import (
 from mypy_extensions import u8
 
 # High-level cache layout format
-CACHE_VERSION: Final = 10
+CACHE_VERSION: Final = 11
 
 # Type used internally to represent errors:
 #   (path, line, column, end_line, end_column, severity, message, code)
@@ -308,6 +311,7 @@ LITERAL_STR: Final[Tag] = 4
 LITERAL_BYTES: Final[Tag] = 5
 LITERAL_FLOAT: Final[Tag] = 6
 LITERAL_COMPLEX: Final[Tag] = 7
+LITERAL_SENTINEL: Final[Tag] = 8
 
 # Collections.
 LIST_GEN: Final[Tag] = 20
@@ -328,7 +332,7 @@ RESERVED: Final[Tag] = 254
 END_TAG: Final[Tag] = 255
 
 
-def read_literal(data: ReadBuffer, tag: Tag) -> int | str | bool | float:
+def read_literal(data: ReadBuffer, tag: Tag) -> int | str | bool | float | SentinelValue:
     if tag == LITERAL_INT:
         return read_int_bare(data)
     elif tag == LITERAL_STR:
@@ -339,12 +343,18 @@ def read_literal(data: ReadBuffer, tag: Tag) -> int | str | bool | float:
         return True
     elif tag == LITERAL_FLOAT:
         return read_float_bare(data)
+    elif tag == LITERAL_SENTINEL:
+        from mypy.types import SentinelValue as _SentinelValue
+
+        return _SentinelValue(read_str_bare(data), read_str_bare(data))
     assert False, f"Unknown literal tag {tag}"
 
 
 # There is an intentional asymmetry between read and write for literals because
 # None and/or complex values are only allowed in some contexts but not in others.
-def write_literal(data: WriteBuffer, value: int | str | bool | float | complex | None) -> None:
+def write_literal(
+    data: WriteBuffer, value: int | str | bool | float | complex | SentinelValue | None
+) -> None:
     if isinstance(value, bool):
         write_bool(data, value)
     elif isinstance(value, int):
@@ -360,8 +370,12 @@ def write_literal(data: WriteBuffer, value: int | str | bool | float | complex |
         write_tag(data, LITERAL_COMPLEX)
         write_float_bare(data, value.real)
         write_float_bare(data, value.imag)
-    else:
+    elif value is None:
         write_tag(data, LITERAL_NONE)
+    else:
+        write_tag(data, LITERAL_SENTINEL)
+        write_str_bare(data, value.fullname)
+        write_str_bare(data, value.name)
 
 
 def read_int(data: ReadBuffer) -> int:

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/messages.py

@@ -2783,6 +2783,8 @@ def format_type_inner(
                 modifier += "="
             items.append(f"{item_name!r}{modifier}: {format(item_type)}")
         return f"TypedDict({{{', '.join(items)}}})"
+    elif isinstance(typ, LiteralType) and typ.is_sentinel_literal():
+        return format_literal_value(typ)
     elif isinstance(typ, LiteralType):
         return f"Literal[{format_literal_value(typ)}]"
     elif isinstance(typ, UnionType):
@@ -2790,6 +2792,9 @@ def format_type_inner(
         if not isinstance(typ, UnionType):
             return format(typ)
         literal_items, union_items = separate_union_literals(typ)
+        sentinel_items = [item for item in literal_items if item.is_sentinel_literal()]
+        literal_items = [item for item in literal_items if not item.is_sentinel_literal()]
+        union_items = [*sentinel_items, *union_items]
 
         # Coalesce multiple Literal[] members. This also changes output order.
         # If there's just one Literal item, retain the original ordering.

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/nodes.py

@@ -1416,6 +1416,7 @@ VAR_FLAGS: Final = [
     "from_module_getattr",
     "has_explicit_value",
     "allow_incompatible_override",
+    "is_sentinel",
 ]
 
 
@@ -1454,6 +1455,7 @@ class Var(SymbolNode):
         "allow_incompatible_override",
         "invalid_partial_type",
         "is_argument",
+        "is_sentinel",
     )
 
     __match_args__ = ("name", "type", "final_value")
@@ -1516,6 +1518,8 @@ class Var(SymbolNode):
         self.invalid_partial_type = False
         # Is it a variable symbol for a function argument?
         self.is_argument = False
+        # Was this variable created by PEP 661 sentinel()/Sentinel() syntax?
+        self.is_sentinel = False
 
     @property
     def name(self) -> str:
@@ -1598,6 +1602,7 @@ class Var(SymbolNode):
                 self.from_module_getattr,
                 self.has_explicit_value,
                 self.allow_incompatible_override,
+                self.is_sentinel,
             ],
         )
         write_literal(data, self.final_value)
@@ -1635,12 +1640,15 @@ class Var(SymbolNode):
             v.from_module_getattr,
             v.has_explicit_value,
             v.allow_incompatible_override,
-        ) = read_flags(data, num_flags=19)
+            v.is_sentinel,
+        ) = read_flags(data, num_flags=20)
         tag = read_tag(data)
         if tag == LITERAL_COMPLEX:
             v.final_value = complex(read_float_bare(data), read_float_bare(data))
         elif tag != LITERAL_NONE:
-            v.final_value = read_literal(data, tag)
+            val = read_literal(data, tag)
+            assert not isinstance(val, mypy.types.SentinelValue)
+            v.final_value = val
         assert read_tag(data) == END_TAG
         return v
 

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/plugins/dataclasses.py

@@ -63,6 +63,7 @@ from mypy.types import (
     LiteralType,
     NoneType,
     ProperType,
+    SentinelValue,
     TupleType,
     Type,
     TypeOfAny,
@@ -799,6 +800,9 @@ class DataclassTransformer:
         if node is None:
             return False
         node_type = get_proper_type(node)
+        if isinstance(node_type, LiteralType) and isinstance(node_type.value, SentinelValue):
+            # PEP 661 sentinel: `KW_ONLY = sentinel("KW_ONLY")` (Python 3.15+).
+            return node_type.value.fullname == "dataclasses.KW_ONLY"
         if not isinstance(node_type, Instance):
             return False
         return node_type.type.fullname == "dataclasses.KW_ONLY"

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/semanal.py

@@ -271,6 +271,7 @@ from mypy.types import (
     OVERRIDE_DECORATOR_NAMES,
     PROTOCOL_NAMES,
     REVEAL_TYPE_NAMES,
+    SENTINEL_TYPE_NAMES,
     TPDICT_NAMES,
     TYPE_ALIAS_NAMES,
     TYPE_CHECK_ONLY_NAMES,
@@ -289,6 +290,7 @@ from mypy.types import (
     ParamSpecType,
     PlaceholderType,
     ProperType,
+    SentinelValue,
     TrivialSyntheticTypeTranslator,
     TupleType,
     Type,
@@ -3377,9 +3379,15 @@ class SemanticAnalyzer(
         # may be set to True while there were still placeholders due to forward refs.
         s.is_alias_def = False
 
+        sentinel_definition = self.is_sentinel_declaration(s)
+
         # OK, this is a regular assignment, perform the necessary analysis steps.
         s.is_final_def = self.unwrap_final(s)
+        if sentinel_definition:
+            s.is_final_def = True
         self.analyze_lvalues(s)
+        if sentinel_definition:
+            self.setup_sentinel_var(s)
         self.check_final_implicit_def(s)
         self.store_final_status(s)
         self.check_classvar(s)
@@ -3392,6 +3400,51 @@ class SemanticAnalyzer(
         self.process__deletable__(s)
         self.process__slots__(s)
 
+    def is_sentinel_declaration(self, s: AssignmentStmt) -> bool:
+        """Does this assignment define a PEP 661 sentinel singleton?"""
+        if self.is_nested_within_func_scope() or s.unanalyzed_type is not None:
+            return False
+        if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
+            return False
+        if not isinstance(s.rvalue, CallExpr):
+            return False
+        call = s.rvalue
+        if not isinstance(call.callee, RefExpr):
+            return False
+        if call.callee.fullname not in SENTINEL_TYPE_NAMES:
+            return False
+        if not call.args or call.arg_kinds[0] != ARG_POS or not isinstance(call.args[0], StrExpr):
+            return False
+        return True
+
+    def setup_sentinel_var(self, s: AssignmentStmt) -> None:
+        lvalue = s.lvalues[0]
+        assert isinstance(lvalue, NameExpr)
+        if not isinstance(lvalue.node, Var):
+            return
+        var = lvalue.node
+        var.is_sentinel = True
+        typ = self.sentinel_type_for_var(var, s.rvalue)
+        if typ is not None:
+            s.type = typ
+
+    def sentinel_type_for_var(self, var: Var, rvalue: Expression) -> Instance | None:
+        assert isinstance(rvalue, CallExpr)
+        callee = rvalue.callee
+        assert isinstance(callee, RefExpr)
+        typ = self.named_type_or_none(callee.fullname)
+        if typ is None:
+            return None
+        name = f"{self.type.name}.{var.name}" if self.type is not None else var.name
+        return typ.copy_modified(
+            last_known_value=LiteralType(
+                SentinelValue(var.fullname, name),
+                fallback=typ,
+                line=rvalue.line,
+                column=rvalue.column,
+            )
+        )
+
     def analyze_identity_global_assignment(self, s: AssignmentStmt) -> bool:
         """Special case 'X = X' in global scope.
 
@@ -4763,6 +4816,7 @@ class SemanticAnalyzer(
                     var.is_final
                     and isinstance(typ, Instance)
                     and typ.last_known_value
+                    and not isinstance(typ.last_known_value.value, SentinelValue)
                     and (not self.type or not self.type.is_enum)
                 ):
                     var.final_value = typ.last_known_value.value

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/server/deps.py

@@ -158,6 +158,7 @@ from mypy.types import (
     ParamSpecType,
     PartialType,
     ProperType,
+    SentinelValue,
     TupleType,
     Type,
     TypeAliasType,
@@ -1096,7 +1097,10 @@ class TypeTriggersVisitor(TypeVisitor[list[str]]):
         return triggers
 
     def visit_literal_type(self, typ: LiteralType) -> list[str]:
-        return self.get_type_triggers(typ.fallback)
+        triggers = self.get_type_triggers(typ.fallback)
+        if isinstance(typ.value, SentinelValue):
+            triggers.append(make_trigger(typ.value.fullname))
+        return triggers
 
     def visit_unbound_type(self, typ: UnboundType) -> list[str]:
         return []

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/test/testtypes.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 import re
 from unittest import TestCase, skipUnless
 
+from librt.internal import ReadBuffer, WriteBuffer
+
+from mypy.cache import read_tag
 from mypy.erasetype import erase_type, remove_instance_last_known_values
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.join import join_types
@@ -30,6 +33,7 @@ from mypy.test.helpers import Suite, assert_equal, assert_type, skip
 from mypy.test.typefixture import InterfaceTypeFixture, TypeFixture
 from mypy.typeops import false_only, make_simplified_union, true_only
 from mypy.types import (
+    LITERAL_TYPE,
     AnyType,
     CallableType,
     Instance,
@@ -37,6 +41,7 @@ from mypy.types import (
     NoneType,
     Overloaded,
     ProperType,
+    SentinelValue,
     TupleType,
     Type,
     TypedDictType,
@@ -66,6 +71,25 @@ class TypesSuite(Suite):
     def test_any(self) -> None:
         assert_equal(str(AnyType(TypeOfAny.special_form)), "Any")
 
+    def test_sentinel_literal_json_roundtrip(self) -> None:
+        literal = LiteralType(SentinelValue("__main__.MISSING", "MISSING"), self.fx.a)
+        assert_equal(str(literal), "MISSING")
+        data = literal.serialize()
+        assert isinstance(data, dict)
+        roundtrip = LiteralType.deserialize(data)
+        self.assertEqual(roundtrip.value, literal.value)
+        self.assertEqual(roundtrip.fallback.type_ref, self.fx.a.type.fullname)
+
+    def test_sentinel_literal_ff_roundtrip(self) -> None:
+        literal = LiteralType(SentinelValue("__main__.MISSING", "MISSING"), self.fx.a)
+        data = WriteBuffer()
+        literal.write(data)
+        buffer = ReadBuffer(data.getvalue())
+        assert read_tag(buffer) == LITERAL_TYPE
+        roundtrip = LiteralType.read(buffer)
+        self.assertEqual(roundtrip.value, literal.value)
+        self.assertEqual(roundtrip.fallback.type_ref, self.fx.a.type.fullname)
+
     def test_simple_unbound_type(self) -> None:
         u = UnboundType("Foo")
         assert_equal(str(u), "Foo?")

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/typeanal.py

@@ -1050,6 +1050,16 @@ class TypeAnalyser(SyntheticTypeVisitor[Type], TypeAnalyzerPluginInterface):
                 column=t.column,
             )
 
+        if isinstance(sym.node, Var) and sym.node.is_sentinel:
+            typ = get_proper_type(sym.node.type)
+            if isinstance(typ, Instance) and typ.last_known_value is not None:
+                return LiteralType(
+                    value=typ.last_known_value.value,
+                    fallback=typ.last_known_value.fallback,
+                    line=t.line,
+                    column=t.column,
+                )
+
         # None of the above options worked. We parse the args (if there are any)
         # to make sure there are no remaining semanal-only types, then give up.
         t = t.copy_modified(args=self.anal_array(t.args))

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/typeops.py

@@ -1058,7 +1058,7 @@ def is_singleton_identity_type(typ: ProperType) -> bool:
             or (typ.type.fullname in NOT_IMPLEMENTED_TYPE_NAMES)
         )
     if isinstance(typ, LiteralType):
-        return typ.is_enum_literal() or isinstance(typ.value, bool)
+        return typ.is_enum_literal() or typ.is_sentinel_literal() or isinstance(typ.value, bool)
     if isinstance(typ, TypeType) and isinstance(typ.item, Instance) and typ.item.type.is_final:
         return True
     if isinstance(typ, FunctionLike) and typ.is_type_obj() and typ.type_object().is_final:

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy/types.py

@@ -67,6 +67,7 @@ T = TypeVar("T")
 
 JsonDict: _TypeAlias = dict[str, Any]
 
+
 # The set of all valid expressions that can currently be contained
 # inside of a Literal[...].
 #
@@ -97,7 +98,12 @@ JsonDict: _TypeAlias = dict[str, Any]
 #
 # Note: Float values are only used internally. They are not accepted within
 # Literal[...].
-LiteralValue: _TypeAlias = int | str | bool | float
+class SentinelValue(NamedTuple):
+    fullname: str
+    name: str
+
+
+LiteralValue: _TypeAlias = int | str | bool | float | SentinelValue
 
 
 TUPLE_NAMES: Final = ("builtins.tuple", "typing.Tuple")
@@ -112,6 +118,12 @@ TYPE_VAR_LIKE_NAMES: Final = (
     "typing_extensions.TypeVarTuple",
 )
 
+SENTINEL_TYPE_NAMES: Final = (
+    "builtins.sentinel",
+    "typing_extensions.sentinel",
+    "typing_extensions.Sentinel",
+)
+
 TYPED_NAMEDTUPLE_NAMES: Final = ("typing.NamedTuple", "typing_extensions.NamedTuple")
 
 # Supported names of TypedDict type constructors.
@@ -3342,11 +3354,15 @@ class LiteralType(ProperType):
     #       almost no test cases where we would redundantly compute
     #       `can_be_false`/`can_be_true`.
     def can_be_false_default(self) -> bool:
+        if isinstance(self.value, SentinelValue):
+            return False
         if self.fallback.type.is_enum:
             return self.fallback.can_be_false
         return not self.value
 
     def can_be_true_default(self) -> bool:
+        if isinstance(self.value, SentinelValue):
+            return True
         if self.fallback.type.is_enum:
             return self.fallback.can_be_true
         return bool(self.value)
@@ -3367,6 +3383,9 @@ class LiteralType(ProperType):
     def is_enum_literal(self) -> bool:
         return self.fallback.type.is_enum
 
+    def is_sentinel_literal(self) -> bool:
+        return isinstance(self.value, SentinelValue)
+
     def value_repr(self) -> str:
         """Returns the string representation of the underlying type.
 
@@ -3374,6 +3393,9 @@ class LiteralType(ProperType):
         except it includes some additional logic to correctly handle cases
         where the value is a string, byte string, a unicode string, or an enum.
         """
+        if isinstance(self.value, SentinelValue):
+            return self.value.name
+
         raw = repr(self.value)
         fallback_name = self.fallback.type.fullname
 
@@ -3392,16 +3414,19 @@ class LiteralType(ProperType):
             return raw
 
     def serialize(self) -> JsonDict | str:
-        return {
-            ".class": "LiteralType",
-            "value": self.value,
-            "fallback": self.fallback.serialize(),
-        }
+        value: LiteralValue | JsonDict = self.value
+        if isinstance(value, SentinelValue):
+            value = {".class": "SentinelValue", "fullname": value.fullname, "name": value.name}
+        return {".class": "LiteralType", "value": value, "fallback": self.fallback.serialize()}
 
     @classmethod
     def deserialize(cls, data: JsonDict) -> LiteralType:
         assert data[".class"] == "LiteralType"
-        return LiteralType(value=data["value"], fallback=Instance.deserialize(data["fallback"]))
+        value = data["value"]
+        if isinstance(value, dict):
+            assert value[".class"] == "SentinelValue"
+            value = SentinelValue(value["fullname"], value["name"])
+        return LiteralType(value=value, fallback=Instance.deserialize(data["fallback"]))
 
     def write(self, data: WriteBuffer) -> None:
         write_tag(data, LITERAL_TYPE)
@@ -3414,7 +3439,8 @@ class LiteralType(ProperType):
         assert read_tag(data) == INSTANCE
         fallback = Instance.read(data)
         tag = read_tag(data)
-        ret = LiteralType(read_literal(data, tag), fallback)
+        value = read_literal(data, tag)
+        ret = LiteralType(value, fallback)
         assert read_tag(data) == END_TAG
         return ret
 
@@ -4077,6 +4103,8 @@ class TypeStrVisitor(SyntheticTypeVisitor[str]):
         return repr(t.literal_value)
 
     def visit_literal_type(self, t: LiteralType, /) -> str:
+        if isinstance(t.value, SentinelValue):
+            return t.value_repr()
         return f"Literal[{t.value_repr()}]"
 
     def visit_union_type(self, t: UnionType, /) -> str:

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy-requirements.txt

@@ -5,5 +5,5 @@ typing_extensions>=4.14.0; python_version>='3.15'
 mypy_extensions>=1.0.0
 pathspec>=1.0.0
 tomli>=1.1.0; python_version<'3.11'
-librt>=0.13.0; platform_python_implementation != 'PyPy'
-ast-serialize>=0.6.0,<1.0.0
+librt>=0.15.0; platform_python_implementation != 'PyPy'
+ast-serialize>=0.8.0,<1.0.0

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mypy-dev
-Version: 2.4.0a1
+Version: 2.4.0a2
 Summary: Optional static typing for Python
 Author-email: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
 License-Expression: MIT
@@ -28,8 +28,8 @@ Requires-Dist: typing_extensions>=4.14.0; python_version >= "3.15"
 Requires-Dist: mypy_extensions>=1.0.0
 Requires-Dist: pathspec>=1.0.0
 Requires-Dist: tomli>=1.1.0; python_version < "3.11"
-Requires-Dist: librt>=0.13.0; platform_python_implementation != "PyPy"
-Requires-Dist: ast-serialize<1.0.0,>=0.6.0
+Requires-Dist: librt>=0.15.0; platform_python_implementation != "PyPy"
+Requires-Dist: ast-serialize<1.0.0,>=0.8.0
 Provides-Extra: dmypy
 Requires-Dist: psutil>=4.0; extra == "dmypy"
 Provides-Extra: mypyc

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy_dev.egg-info/SOURCES.txt

@@ -1643,6 +1643,7 @@ test-data/unit/check-redefine2.test
 test-data/unit/check-reports.test
 test-data/unit/check-selftype.test
 test-data/unit/check-semanal-error.test
+test-data/unit/check-sentinels.test
 test-data/unit/check-serialize.test
 test-data/unit/check-singledispatch.test
 test-data/unit/check-slots.test
@@ -1775,6 +1776,7 @@ test-data/unit/fixtures/paramspec.pyi
 test-data/unit/fixtures/plugin_attrs.pyi
 test-data/unit/fixtures/primitives.pyi
 test-data/unit/fixtures/property.pyi
+test-data/unit/fixtures/sentinel.pyi
 test-data/unit/fixtures/set.pyi
 test-data/unit/fixtures/slice.pyi
 test-data/unit/fixtures/staticmethod.pyi

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypy_dev.egg-info/requires.txt

@@ -1,9 +1,9 @@
 mypy_extensions>=1.0.0
 pathspec>=1.0.0
-ast-serialize<1.0.0,>=0.6.0
+ast-serialize<1.0.0,>=0.8.0
 
 [:platform_python_implementation != "PyPy"]
-librt>=0.13.0
+librt>=0.15.0
 
 [:python_version < "3.11"]
 tomli>=1.1.0

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypyc/codegen/emit.py

@@ -22,7 +22,13 @@ from mypyc.common import (
     TYPE_VAR_PREFIX,
 )
 from mypyc.ir.class_ir import ClassIR, all_concrete_classes
-from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncDecl, FuncIR, get_text_signature
+from mypyc.ir.func_ir import (
+    FUNC_CLASSMETHOD,
+    FUNC_STATICMETHOD,
+    FuncDecl,
+    FuncIR,
+    get_text_signature,
+)
 from mypyc.ir.ops import (
     NAMESPACE_MODULE,
     NAMESPACE_STATIC,
@@ -1419,13 +1425,17 @@ class Emitter:
         cname = f"{PREFIX}{fn.cname(self.names)}"
         wrapper_name = f"{cname}_wrapper"
         cfunc = f"(PyCFunction){cname}"
-        func_flags = "METH_FASTCALL | METH_KEYWORDS"
+        func_flags = ["METH_FASTCALL", "METH_KEYWORDS"]
+        if fn.class_name and fn.decl.kind == FUNC_STATICMETHOD:
+            func_flags.append("METH_STATIC")
+        elif fn.class_name and fn.decl.kind == FUNC_CLASSMETHOD:
+            func_flags.append("METH_CLASS")
         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}, {has_self_arg});'
+            f'PyObject* {wrapper_name} = CPyFunction_New({module}, "{filepath}", "{name}", {cfunc}, {" | ".join(func_flags)}, {doc}, {fn.line}, {code_flags}, {has_self_arg});'
         )
         self.emit_line(f"if (unlikely(!{wrapper_name}))")
         self.emit_line(error_stmt)

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypyc/codegen/emitclass.py

@@ -608,9 +608,7 @@ def generate_vtable(
         method = entry.shadow_method if shadow and entry.shadow_method else entry.method
         emitter.emit_line(
             "(CPyVTableItem){}{}{},".format(
-                emitter.get_group_prefix(entry.method.decl),
-                NATIVE_PREFIX,
-                method.cname(emitter.names),
+                emitter.get_group_prefix(method.decl), NATIVE_PREFIX, method.cname(emitter.names)
             )
         )
 
@@ -1360,15 +1358,18 @@ def generate_property_setter(
         )
     )
     emitter.emit_line("{")
+    ret_type = func_ir.ret_type
+    emitter.emit_line(f"{emitter.ctype(ret_type)} retval = {emitter.c_undefined_value(ret_type)};")
     if arg_type.is_unboxed:
         emitter.emit_unbox("value", "tmp", arg_type, error=ReturnHandler("-1"), declare_dest=True)
         emitter.emit_line(
-            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, tmp);"
+            f"retval = {NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, tmp);"
         )
     else:
         emitter.emit_line(
-            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, value);"
+            f"retval = {NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, value);"
         )
+    emitter.emit_error_check("retval", ret_type, "return -1;")
     emitter.emit_line("return 0;")
     emitter.emit_line("}")
 

{mypy_dev-2.4.0a1 → mypy_dev-2.4.0a2}/mypyc/codegen/emitfunc.py

@@ -548,7 +548,7 @@ class FunctionEmitterVisitor(OpVisitor[None]):
         rtype = op.class_type
         cl = rtype.class_ir
         attr_rtype, decl_cl = cl.attr_details(op.attr)
-        if op.is_propset:
+        if op.propset is not None:
             # Again, use vtable access for properties...
             assert not op.is_init and op.error_kind == ERR_FALSE, "%s %d %d %s" % (
                 op.attr,
@@ -557,10 +557,14 @@ class FunctionEmitterVisitor(OpVisitor[None]):
                 rtype,
             )
             version = "_TRAIT" if cl.is_trait else ""
+            ret_type = op.propset.sig.ret_type
+            c_ret_type = self.emitter.ctype(ret_type)
+            tmp = self.temp_name()
             self.emit_line(
-                "%s = CPY_SET_ATTR%s(%s, %s, %d, %s, %s, %s); /* %s */"
+                "%s %s = CPY_SET_ATTR%s(%s, %s, %d, %s, %s, %s, %s); /* %s */"
                 % (
-                    dest,
+                    c_ret_type,
+                    tmp,
                     version,
                     obj,
                     self.emitter.type_struct_name(rtype.class_ir),
@@ -568,9 +572,12 @@ class FunctionEmitterVisitor(OpVisitor[None]):
                     src,
                     rtype.struct_name(self.names),
                     self.ctype(rtype.attr_type(op.attr)),
+                    c_ret_type,
                     op.attr,
                 )
             )
+            self.emit_line(f"{dest} = 1;")
+            self.emitter.emit_error_check(tmp, ret_type, f"{dest} = 0;")
         elif IS_FREE_THREADED and is_simple_refcounted_pointer(attr_rtype):
             # In free-threaded builds, publishing a single reference-counted
             # 'PyObject *' field must be atomic so a concurrent reader (see