sqlglot-mypy 2.1.0.post1__tar.gz → 2.1.0.post3__tar.gz

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot-mypy
-Version: 2.1.0.post1
+Version: 2.1.0.post3
 Summary: Optional static typing for Python
 Author-email: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
 License-Expression: MIT

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypy/version.py

@@ -8,7 +8,7 @@ from mypy import git
 # - Release versions have the form "1.2.3".
 # - Dev versions have the form "1.2.3+dev" (PLUS sign to conform to PEP 440).
 # - Before 1.0 we had the form "0.NNN".
-__version__ = "2.1.0.post1"
+__version__ = "2.1.0.post3"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/build.py

@@ -597,8 +597,14 @@ def get_header_deps(cfiles: list[tuple[str, str]]) -> list[tuple[bool, str]]:
     the on-disk headers after every group has written its files.
 
     Arguments:
-        cfiles: A list of (file name, file contents) pairs.
+        cfiles: A list of (file name, file contents) pairs. Contents must be
+            non-empty; callers handling cached groups must re-read the .c
+            from disk before calling, otherwise direct includes are missed
+            and Extension.depends ends up empty.
     """
+    assert all(
+        contents for _, contents in cfiles
+    ), "get_header_deps requires non-empty file contents"
     headers: set[tuple[bool, str]] = set()
     for _, contents in cfiles:
         headers.update(_extract_includes(contents))
@@ -737,7 +743,18 @@ def mypyc_build(
                 write_file(cfile_full, ctext)
             if os.path.splitext(cfile_full)[1] == ".c":
                 cfilenames.append(cfile_full)
-            per_cfile_deps.append((cfile_full, get_header_deps([(cfile, ctext)])))
+            # For fully-cached groups ctext is empty; read the on-disk .c so the dep resolver
+            # can walk its transitive header chain and populate Extension.depends. Otherwise,
+            # cross-group export-table header changes (e.g. a new class shifting struct offsets)
+            # won't trigger a recompile of this cached consumer's .o.
+            if not ctext and os.path.exists(cfile_full):
+                try:
+                    with open(cfile_full, encoding="utf-8") as _f:
+                        ctext = _f.read()
+                except OSError:
+                    pass
+            if ctext:
+                per_cfile_deps.append((cfile_full, get_header_deps([(cfile, ctext)])))
 
         # Fully-cached mypy build (typical of pip's second setup.py invocation
         # for the wheel-build phase): mypyc returns an empty ctext for the
@@ -758,9 +775,10 @@ def mypyc_build(
                         existing_text = _f.read()
                 except OSError:
                     existing_text = ""
-                per_cfile_deps.append(
-                    (existing, get_header_deps([(os.path.basename(existing), existing_text)]))
-                )
+                if existing_text:
+                    per_cfile_deps.append(
+                        (existing, get_header_deps([(os.path.basename(existing), existing_text)]))
+                    )
 
         pending.append(per_cfile_deps)
         group_cfilenames.append((cfilenames, []))

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/codegen/emitclass.py

@@ -29,6 +29,7 @@ from mypyc.common import (
     BITMAP_BITS,
     BITMAP_TYPE,
     CPYFUNCTION_NAME,
+    MYPYC_DEFAULTS_SETUP,
     NATIVE_PREFIX,
     PREFIX,
     REG_PREFIX,
@@ -285,7 +286,7 @@ def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
 
     # If the class has a method to initialize default attribute
     # values, we need to call it during initialization.
-    defaults_fn = cl.get_method("__mypyc_defaults_setup")
+    defaults_fn = cl.get_method(MYPYC_DEFAULTS_SETUP)
 
     # If there is a __init__ method, we'll use it in the native constructor.
     init_fn = cl.get_method("__init__")

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/common.py

@@ -24,6 +24,7 @@ TEMP_ATTR_NAME: Final = "__mypyc_temp__"
 LAMBDA_NAME: Final = "__mypyc_lambda__"
 PROPSET_PREFIX: Final = "__mypyc_setter__"
 SELF_NAME: Final = "__mypyc_self__"
+MYPYC_DEFAULTS_SETUP: Final = "__mypyc_defaults_setup"
 GENERATOR_ATTRIBUTE_PREFIX: Final = "__mypyc_generator_attribute__"
 CPYFUNCTION_NAME = "__cpyfunction__"
 

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/irbuild/classdef.py

@@ -7,6 +7,7 @@ from collections.abc import Callable
 from typing import Final
 
 from mypy.nodes import (
+    ARG_POS,
     EXCLUDED_ENUM_ATTRIBUTES,
     TYPE_VAR_TUPLE_KIND,
     AssignmentStmt,
@@ -21,7 +22,6 @@ from mypy.nodes import (
     NameExpr,
     OverloadedFuncDef,
     PassStmt,
-    RefExpr,
     StrExpr,
     TempNode,
     TypeInfo,
@@ -29,7 +29,7 @@ from mypy.nodes import (
     is_class_var,
 )
 from mypy.types import Instance, UnboundType, get_proper_type
-from mypyc.common import PROPSET_PREFIX
+from mypyc.common import MYPYC_DEFAULTS_SETUP, PROPSET_PREFIX
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
 from mypyc.ir.func_ir import FuncDecl, FuncSignature
 from mypyc.ir.ops import (
@@ -48,15 +48,7 @@ from mypyc.ir.ops import (
     TupleSet,
     Value,
 )
-from mypyc.ir.rtypes import (
-    RType,
-    bool_rprimitive,
-    dict_rprimitive,
-    is_none_rprimitive,
-    is_object_rprimitive,
-    is_optional_type,
-    object_rprimitive,
-)
+from mypyc.ir.rtypes import RType, bool_rprimitive, dict_rprimitive, object_rprimitive
 from mypyc.irbuild.builder import IRBuilder, create_type_params
 from mypyc.irbuild.function import (
     gen_property_getter_ir,
@@ -66,7 +58,13 @@ from mypyc.irbuild.function import (
     load_type,
 )
 from mypyc.irbuild.prepare import GENERATOR_HELPER_NAME
-from mypyc.irbuild.util import dataclass_type, get_func_def, is_constant, is_dataclass_decorator
+from mypyc.irbuild.util import (
+    dataclass_type,
+    default_attr_name,
+    get_func_def,
+    is_constant,
+    is_dataclass_decorator,
+)
 from mypyc.primitives.dict_ops import dict_new_op, exact_dict_set_item_op
 from mypyc.primitives.generic_ops import (
     iter_op,
@@ -322,10 +320,6 @@ class ExtClassBuilder(ClassBuilder):
     def class_body_obj(self) -> Value | None:
         return self.type_obj
 
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        """Controls whether to skip generating a default for an attribute."""
-        return False
-
     def add_method(self, fdef: FuncDef) -> None:
         handle_ext_method(self.builder, self.cdef, fdef)
 
@@ -348,11 +342,18 @@ class ExtClassBuilder(ClassBuilder):
         # Call __init_subclass__ after class attributes have been set
         self.builder.call_c(py_init_subclass_op, [self.type_obj], self.cdef.line)
 
-        attrs_with_defaults, default_assignments = find_attr_initializers(
-            self.builder, self.cdef, self.skip_attr_default
-        )
-        ir.attrs_with_defaults.update(attrs_with_defaults)
-        generate_attr_defaults_init(self.builder, self.cdef, default_assignments)
+        # Under separate compilation, prepare.py pre-registers the decl iff
+        # the class has its own default attribute assignments to emit, so we
+        # can skip the body walk entirely when it isn't present. Without
+        # separate compilation, find_attr_initializers walks the MRO so that
+        # inherited defaults are reflected in ir.attrs_with_defaults (relied
+        # on by the attribute-definedness analysis), so we always run it.
+        if not self.builder.options.separate or MYPYC_DEFAULTS_SETUP in ir.method_decls:
+            attrs_with_defaults, default_assignments = find_attr_initializers(
+                self.builder, self.cdef
+            )
+            ir.attrs_with_defaults.update(attrs_with_defaults)
+            generate_attr_defaults_init(self.builder, self.cdef, default_assignments)
         create_ne_from_eq(self.builder, self.cdef)
 
 
@@ -380,9 +381,6 @@ class DataClassBuilder(ExtClassBuilder):
             self.builder.add(LoadAddress(type_object_op.type, type_object_op.src, self.cdef.line)),
         )
 
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        return stmt.type is not None
-
     def get_type_annotation(self, stmt: AssignmentStmt) -> TypeInfo | None:
         # We populate __annotations__ because dataclasses uses it to determine
         # which attributes to compute on.
@@ -445,9 +443,6 @@ class AttrsClassBuilder(DataClassBuilder):
 
     add_annotations_to_dict = False
 
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        return True
-
     def get_type_annotation(self, stmt: AssignmentStmt) -> TypeInfo | None:
         if isinstance(stmt.rvalue, CallExpr):
             # find the type arg in `attr.ib(type=str)`
@@ -741,58 +736,50 @@ def add_non_ext_class_attr(
 
 
 def find_attr_initializers(
-    builder: IRBuilder, cdef: ClassDef, skip: Callable[[str, AssignmentStmt], bool] | None = None
+    builder: IRBuilder, cdef: ClassDef
 ) -> tuple[set[str], list[tuple[AssignmentStmt, str]]]:
     """Find initializers of attributes in a class body.
 
-    If provided, the skip arg should be a callable which will return whether
-    to skip generating a default for an attribute.  It will be passed the name of
-    the attribute and the corresponding AssignmentStmt.
+    Under separate compilation, only this class's own body is walked, and
+    generate_attr_defaults_init emits a runtime call to the parent's
+    __mypyc_defaults_setup so inherited defaults are produced by chaining,
+    not by inlining. Walking the MRO here would break under separate=True
+    with mypy's incremental cache: a base class loaded from the cache has
+    an empty ClassDef.defs.body (mypy/nodes.py::ClassDef.serialize doesn't
+    serialize the class body), so inherited assignments would be silently
+    dropped and the subclass's __mypyc_defaults_setup would leave inherited
+    slots in the "undefined" state at runtime.
+
+    Without separate compilation, all modules are parsed in the same pass
+    and the MRO walk is safe; we keep the original inline-all behavior
+    there as an optimization (no chain call needed for instance creation).
     """
     cls = builder.mapper.type_to_ir[cdef.info]
     if cls.builtin_base:
         return set(), []
 
-    attrs_with_defaults = set()
+    cls_type = dataclass_type(cdef)
+    attrs_with_defaults: set[str] = set()
+    default_assignments: list[tuple[AssignmentStmt, str]] = []
 
-    # Pull out all assignments in classes in the mro so we can initialize them
     # TODO: Support nested statements
-    default_assignments: list[tuple[AssignmentStmt, str]] = []
-    for info in reversed(cdef.info.mro):
-        if info not in builder.mapper.type_to_ir:
+    if builder.options.separate:
+        infos: list[TypeInfo] = [cdef.info]
+    else:
+        infos = list(reversed(cdef.info.mro))
+
+    for info in infos:
+        info_ir = builder.mapper.type_to_ir.get(info)
+        if info_ir is None:
             continue
         for stmt in info.defn.defs.body:
-            if (
-                isinstance(stmt, AssignmentStmt)
-                and isinstance(stmt.lvalues[0], NameExpr)
-                and not is_class_var(stmt.lvalues[0])
-                and not isinstance(stmt.rvalue, TempNode)
-            ):
-                name = stmt.lvalues[0].name
-                if name == "__slots__":
-                    continue
-
-                if name == "__deletable__":
-                    check_deletable_declaration(builder, cls, stmt.line)
-                    continue
-
-                if skip is not None and skip(name, stmt):
-                    continue
-
-                attr_type = cls.attr_type(name)
-
-                # If the attribute is initialized to None and type isn't optional,
-                # doesn't initialize it to anything (special case for "# type:" comments).
-                if isinstance(stmt.rvalue, RefExpr) and stmt.rvalue.fullname == "builtins.None":
-                    if (
-                        not is_optional_type(attr_type)
-                        and not is_object_rprimitive(attr_type)
-                        and not is_none_rprimitive(attr_type)
-                    ):
-                        continue
-
-                attrs_with_defaults.add(name)
-                default_assignments.append((stmt, info.module_name))
+            if not isinstance(stmt, AssignmentStmt):
+                continue
+            name = default_attr_name(stmt, info_ir, cls_type)
+            if name is None:
+                continue
+            attrs_with_defaults.add(name)
+            default_assignments.append((stmt, info.module_name))
 
     return attrs_with_defaults, default_assignments
 
@@ -800,15 +787,49 @@ def find_attr_initializers(
 def generate_attr_defaults_init(
     builder: IRBuilder, cdef: ClassDef, default_assignments: list[tuple[AssignmentStmt, str]]
 ) -> None:
-    """Generate an initialization method for default attr values (from class vars)."""
-    if not default_assignments:
-        return
+    """Generate an initialization method for default attr values (from class vars).
+
+    Under separate compilation, the emitted __mypyc_defaults_setup chains to
+    the nearest ancestor that has the method (Python __init__ style), then
+    sets only this class's own defaults; inherited defaults are produced by
+    the chain at runtime. The ancestor lookup uses cls.mro[1:] and relies on
+    prepare.py having registered the FuncDecl on every class that needs one
+    before any IR build runs. IR build within a compilation group proceeds
+    in filename order, so this class may be IR-built before its base, and a
+    method_decls lookup that depended on the base having been IR-built first
+    would miss. Without separate compilation, find_attr_initializers has
+    already collected the full MRO's defaults into default_assignments, so
+    we inline them all as before.
+    """
     cls = builder.mapper.type_to_ir[cdef.info]
     if cls.builtin_base:
         return
 
-    with builder.enter_method(cls, "__mypyc_defaults_setup", bool_rprimitive):
+    parent_with_defaults: ClassIR | None = None
+    if builder.options.separate:
+        for ancestor in cls.mro[1:]:
+            if MYPYC_DEFAULTS_SETUP in ancestor.method_decls:
+                parent_with_defaults = ancestor
+                break
+
+    if not default_assignments and parent_with_defaults is None:
+        return
+
+    with builder.enter_method(cls, MYPYC_DEFAULTS_SETUP, bool_rprimitive):
         self_var = builder.self()
+
+        # Chain to parent's setup so inherited defaults run first; propagate
+        # its False return so a parent default that raised still aborts
+        # instance creation rather than being silently swallowed here.
+        if parent_with_defaults is not None:
+            decl = parent_with_defaults.method_decl(MYPYC_DEFAULTS_SETUP)
+            parent_ok = builder.builder.call(decl, [self_var], [ARG_POS], [None], cdef.line)
+            fail_block, continue_block = BasicBlock(), BasicBlock()
+            builder.add(Branch(parent_ok, continue_block, fail_block, Branch.BOOL))
+            builder.activate_block(fail_block)
+            builder.add(Return(builder.false()))
+            builder.activate_block(continue_block)
+
         for stmt, origin_module in default_assignments:
             lvalue = stmt.lvalues[0]
             assert isinstance(lvalue, NameExpr), lvalue
@@ -833,26 +854,6 @@ def generate_attr_defaults_init(
         builder.add(Return(builder.true()))
 
 
-def check_deletable_declaration(builder: IRBuilder, cl: ClassIR, line: int) -> None:
-    for attr in cl.deletable:
-        if attr not in cl.attributes:
-            if not cl.has_attr(attr):
-                builder.error(f'Attribute "{attr}" not defined', line)
-                continue
-            for base in cl.mro:
-                if attr in base.property_types:
-                    builder.error(f'Cannot make property "{attr}" deletable', line)
-                    break
-            else:
-                _, base = cl.attr_details(attr)
-                builder.error(
-                    ('Attribute "{}" not defined in "{}" ' + '(defined in "{}")').format(
-                        attr, cl.name, base.name
-                    ),
-                    line,
-                )
-
-
 def create_ne_from_eq(builder: IRBuilder, cdef: ClassDef) -> None:
     """Create a "__ne__" method from a "__eq__" method (if only latter exists)."""
     cls = builder.mapper.type_to_ir[cdef.info]

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/irbuild/prepare.py

@@ -21,6 +21,7 @@ from mypy.build import Graph
 from mypy.nodes import (
     ARG_STAR,
     ARG_STAR2,
+    AssignmentStmt,
     CallExpr,
     ClassDef,
     Decorator,
@@ -39,7 +40,13 @@ from mypy.nodes import (
 from mypy.semanal import refers_to_fullname
 from mypy.traverser import TraverserVisitor
 from mypy.types import Instance, Type, get_proper_type
-from mypyc.common import FAST_PREFIX, PROPSET_PREFIX, SELF_NAME, get_id_from_name
+from mypyc.common import (
+    FAST_PREFIX,
+    MYPYC_DEFAULTS_SETUP,
+    PROPSET_PREFIX,
+    SELF_NAME,
+    get_id_from_name,
+)
 from mypyc.crash import catch_errors
 from mypyc.errors import Errors
 from mypyc.ir.class_ir import ClassIR
@@ -55,6 +62,7 @@ from mypyc.ir.ops import DeserMaps
 from mypyc.ir.rtypes import (
     RInstance,
     RType,
+    bool_rprimitive,
     dict_rprimitive,
     none_rprimitive,
     object_pointer_rprimitive,
@@ -63,6 +71,8 @@ from mypyc.ir.rtypes import (
 )
 from mypyc.irbuild.mapper import Mapper
 from mypyc.irbuild.util import (
+    dataclass_type,
+    default_attr_name,
     get_func_def,
     get_mypyc_attrs,
     is_dataclass,
@@ -131,6 +141,24 @@ def build_type_map(
         if class_ir.is_ext_class:
             prepare_implicit_property_accessors(cdef.info, class_ir, module.fullname, mapper)
 
+    # Register __mypyc_defaults_setup FuncDecls on classes that have their own
+    # class-level default attribute assignments. Done here, before any IR build
+    # runs, so that the cross-class lookup in generate_attr_defaults_init is
+    # order-independent: IR build within a compilation group proceeds in
+    # filename order, so a subclass may be IR-built before its base.
+    for module, cdef in classes:
+        class_ir = mapper.type_to_ir[cdef.info]
+        if class_ir.is_ext_class and _has_own_default_attrs(cdef, class_ir):
+            _register_defaults_setup_decl(class_ir, module.fullname)
+
+    # Validate __deletable__ declarations. Done here so the compiler exits
+    # early on invalid input before any IR is built.
+    for module, cdef in classes:
+        class_ir = mapper.type_to_ir[cdef.info]
+        if class_ir.is_ext_class:
+            with catch_errors(module.path, cdef.line):
+                _check_deletable_declarations(module.path, cdef, class_ir, errors)
+
     # Collect all the functions also. We collect from the symbol table
     # so that we can easily pick out the right copy of a function that
     # is conditionally defined. This doesn't include nested functions!
@@ -408,6 +436,68 @@ def validate_acyclic_class_bases(
         )
 
 
+def _has_own_default_attrs(cdef: ClassDef, ir: ClassIR) -> bool:
+    """Whether this class's own body has any default attribute assignment
+    that would be emitted into __mypyc_defaults_setup.
+
+    Used during prepare to decide whether to register a
+    __mypyc_defaults_setup FuncDecl ahead of IR build.
+    """
+    if ir.builtin_base or ir.is_trait:
+        return False
+    cls_type = dataclass_type(cdef)
+    return any(
+        default_attr_name(stmt, ir, cls_type) is not None
+        for stmt in cdef.info.defn.defs.body
+        if isinstance(stmt, AssignmentStmt)
+    )
+
+
+def _register_defaults_setup_decl(ir: ClassIR, module_name: str) -> None:
+    sig = FuncSignature([RuntimeArg(SELF_NAME, RInstance(ir))], bool_rprimitive)
+    ir.method_decls[MYPYC_DEFAULTS_SETUP] = FuncDecl(
+        MYPYC_DEFAULTS_SETUP, ir.name, module_name, sig
+    )
+
+
+def _check_deletable_declarations(path: str, cdef: ClassDef, ir: ClassIR, errors: Errors) -> None:
+    """Validate that attributes listed in __deletable__ refer to definable
+    attributes on the class.
+
+    Runs in the prepare phase so we exit early on invalid programs before
+    any IR is built.
+    """
+    if not ir.deletable:
+        return
+    line = next(
+        (
+            stmt.line
+            for stmt in cdef.info.defn.defs.body
+            if isinstance(stmt, AssignmentStmt)
+            and isinstance(stmt.lvalues[0], NameExpr)
+            and stmt.lvalues[0].name == "__deletable__"
+        ),
+        cdef.line,
+    )
+    for attr in ir.deletable:
+        if attr not in ir.attributes:
+            if not ir.has_attr(attr):
+                errors.error(f'Attribute "{attr}" not defined', path, line)
+                continue
+            for base in ir.mro:
+                if attr in base.property_types:
+                    errors.error(f'Cannot make property "{attr}" deletable', path, line)
+                    break
+            else:
+                _, base = ir.attr_details(attr)
+                errors.error(
+                    f'Attribute "{attr}" not defined in "{ir.name}" '
+                    f'(defined in "{base.name}")',
+                    path,
+                    line,
+                )
+
+
 def prepare_class_def(
     path: str,
     module_name: str,

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/irbuild/util.py

@@ -12,6 +12,7 @@ from mypy.nodes import (
     ARG_POS,
     GDEF,
     ArgKind,
+    AssignmentStmt,
     BytesExpr,
     CallExpr,
     ClassDef,
@@ -24,13 +25,17 @@ from mypy.nodes import (
     OverloadedFuncDef,
     RefExpr,
     StrExpr,
+    TempNode,
     TupleExpr,
     UnaryExpr,
     Var,
+    is_class_var,
 )
 from mypy.semanal import refers_to_fullname
 from mypy.types import FINAL_DECORATOR_NAMES
 from mypyc.errors import Errors
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.rtypes import is_none_rprimitive, is_object_rprimitive, is_optional_type
 
 MYPYC_ATTRS: Final[frozenset[MypycAttr]] = frozenset(
     ["native_class", "allow_interpreted_subclasses", "serializable", "free_list_len", "acyclic"]
@@ -102,6 +107,50 @@ def dataclass_type(cdef: ClassDef) -> str | None:
     return None
 
 
+def _defaults_skip(stmt: AssignmentStmt, cls_type: str | None) -> bool:
+    """Whether a class-level default assignment is skipped when emitting
+    __mypyc_defaults_setup, based on class type.
+
+    - attr (auto_attribs=False): skip all (handled by attr.ib machinery).
+    - dataclasses / attr-auto: skip annotated assignments.
+    - regular extension class: skip nothing.
+    """
+    if cls_type == "attr":
+        return True
+    if cls_type in ("dataclasses", "attr-auto"):
+        return stmt.type is not None
+    return False
+
+
+def default_attr_name(stmt: AssignmentStmt, ir: ClassIR, cls_type: str | None) -> str | None:
+    """Return the attribute name if `stmt` is a class-level default assignment
+    that __mypyc_defaults_setup should emit; otherwise None.
+
+    Single source of truth for the predicate used by both
+    mypyc.irbuild.classdef.find_attr_initializers (IR build) and
+    mypyc.irbuild.prepare._has_own_default_attrs (prepare-phase decl registration).
+    """
+    lvalue = stmt.lvalues[0]
+    if not isinstance(lvalue, NameExpr) or is_class_var(lvalue):
+        return None
+    if isinstance(stmt.rvalue, TempNode):
+        return None
+    name = lvalue.name
+    if name in ("__slots__", "__deletable__") or name not in ir.attributes:
+        return None
+    if _defaults_skip(stmt, cls_type):
+        return None
+    if isinstance(stmt.rvalue, RefExpr) and stmt.rvalue.fullname == "builtins.None":
+        attr_type = ir.attributes[name]
+        if (
+            not is_optional_type(attr_type)
+            and not is_object_rprimitive(attr_type)
+            and not is_none_rprimitive(attr_type)
+        ):
+            return None
+    return name
+
+
 def get_mypyc_attr_literal(e: Expression) -> Any:
     """Convert an expression from a mypyc_attr decorator to a value.
 

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/test/testutil.py

@@ -232,8 +232,14 @@ def show_c(cfiles: list[list[tuple[str, str]]]) -> None:
 
 
 def fudge_dir_mtimes(dir: str, delta: int) -> None:
+    # Skip linker outputs. Pushing them back combines with write_file's
+    # +1 sec bump on .c files to make .c always newer than .so, forcing
+    # an unconditional rebuild that would mask Extension.depends bugs.
+    # See setuptools/_distutils/command/build_ext.py:`build_extension`.
     for dirpath, _, filenames in os.walk(dir):
         for name in filenames:
+            if name.endswith((".so", ".pyd", ".o", ".obj")):
+                continue
             path = os.path.join(dirpath, name)
             new_mtime = os.stat(path).st_mtime + delta
             os.utime(path, times=(new_mtime, new_mtime))

{sqlglot_mypy-2.1.0.post1 → sqlglot_mypy-2.1.0.post3}/mypyc/test-data/irbuild-classes.test

@@ -1136,7 +1136,7 @@ class Ok2:
     __deletable__ = ['x']
     x: int
 
-[case testInvalidDeletableAttribute]
+[case testDeleteNonDeletableAttribute]
 class NotDeletable:
     __deletable__ = ['x']
     x: int
@@ -1147,6 +1147,7 @@ def g(o: NotDeletable) -> None:
     del o.y  # E: "y" cannot be deleted \
              # N: Using "__deletable__ = ['<attr>']" in the class body enables "del obj.<attr>"
 
+[case testInvalidDeletableAttribute]
 class Base:
     x: int