[mypyc] Fix AttributeError in async try/finally with mixed return paths

Async functions with try/finally blocks were raising AttributeError when:
- Some paths in the try block return while others don't
- The non-return path is executed at runtime
- No further await calls are needed

This occurred because mypyc's IR requires all control flow paths to assign
to spill targets (temporary variables stored as generator attributes). The
non-return path assigns NULL to maintain this invariant, but reading NULL
attributes raises AttributeError in Python.

Created a new IR operation `GetAttrNullable` that can read NULL attributes
without raising AttributeError. This operation is used specifically in
try/finally resolution when reading spill targets.

- Added `GetAttrNullable` class to mypyc/ir/ops.py with error_kind=ERR_NEVER
- Added `read_nullable_attr` method to IRBuilder for creating these operations
- Modified `try_finally_resolve_control` in statement.py to use GetAttrNullable
  only for spill targets (attributes starting with '__mypyc_temp__')
- Implemented C code generation in emitfunc.py that reads attributes without
  NULL checks and only increments reference count if not NULL
- Added visitor implementations to all required files:
  - ir/pprint.py (pretty printing)
  - analysis/dataflow.py (dataflow analysis)
  - analysis/ircheck.py (IR validation)
  - analysis/selfleaks.py (self leak analysis)
  - transform/ir_transform.py (IR transformation)

1. **Separate operation vs flag**: Created a new operation instead of adding
   a flag to GetAttr for better performance - avoids runtime flag checks on
   every attribute access.

2. **Targeted fix**: Only applied to spill targets in try/finally resolution,
   not a general replacement for GetAttr. This minimizes risk and maintains
   existing behavior for all other attribute access.

3. **No initialization changes**: Initially tried initializing spill targets
   to Py_None instead of NULL, but this would incorrectly make try/finally
   blocks return None instead of falling through to subsequent code.

Added two test cases to mypyc/test-data/run-async.test:

1. **testAsyncTryFinallyMixedReturn**: Tests the basic issue with async
   try/finally blocks containing mixed return/non-return paths.

2. **testAsyncWithMixedReturn**: Tests async with statements (which use
   try/finally under the hood) to ensure the fix works for this common
   pattern as well.

Both tests verify that the AttributeError no longer occurs when taking
the non-return path through the try block.

See mypyc/mypyc#1115

Author: Chainfire

mypyc/analysis/dataflow.py

@@ -24,6 +24,7 @@
     FloatNeg,
     FloatOp,
     GetAttr,
+    GetAttrNullable,
     GetElementPtr,
     Goto,
     IncRef,
@@ -209,6 +210,9 @@ def visit_load_literal(self, op: LoadLiteral) -> GenAndKill[T]:
     def visit_get_attr(self, op: GetAttr) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
     def visit_set_attr(self, op: SetAttr) -> GenAndKill[T]:
         return self.visit_register_op(op)
 

mypyc/analysis/ircheck.py

@@ -21,6 +21,7 @@
     FloatNeg,
     FloatOp,
     GetAttr,
+    GetAttrNullable,
     GetElementPtr,
     Goto,
     IncRef,
@@ -319,6 +320,10 @@ def visit_get_attr(self, op: GetAttr) -> None:
         # Nothing to do.
         pass
 
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> None:
+        # Nothing to do.
+        pass
+
     def visit_set_attr(self, op: SetAttr) -> None:
         # Nothing to do.
         pass

mypyc/analysis/selfleaks.py

@@ -16,6 +16,7 @@
     FloatNeg,
     FloatOp,
     GetAttr,
+    GetAttrNullable,
     GetElementPtr,
     Goto,
     InitStatic,
@@ -114,6 +115,13 @@ def visit_get_attr(self, op: GetAttr) -> GenAndKill:
             return self.check_register_op(op)
         return CLEAN
 
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> GenAndKill:
+        cl = op.class_type.class_ir
+        if cl.get_method(op.attr):
+            # Property -- calls a function
+            return self.check_register_op(op)
+        return CLEAN
+
     def visit_set_attr(self, op: SetAttr) -> GenAndKill:
         cl = op.class_type.class_ir
         if cl.get_method(op.attr):

mypyc/codegen/emitfunc.py

@@ -40,6 +40,7 @@
     FloatNeg,
     FloatOp,
     GetAttr,
+    GetAttrNullable,
     GetElementPtr,
     Goto,
     IncRef,
@@ -426,6 +427,24 @@ def visit_get_attr(self, op: GetAttr) -> None:
             elif not always_defined:
                 self.emitter.emit_line("}")
 
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> None:
+        """Handle GetAttrNullable which allows NULL without raising AttributeError."""
+        dest = self.reg(op)
+        obj = self.reg(op.obj)
+        rtype = op.class_type
+        cl = rtype.class_ir
+        attr_rtype, decl_cl = cl.attr_details(op.attr)
+
+        # Direct struct access without NULL check
+        attr_expr = self.get_attr_expr(obj, op, decl_cl)
+        self.emitter.emit_line(f"{dest} = {attr_expr};")
+
+        # Only emit inc_ref if not NULL
+        if attr_rtype.is_refcounted and not op.is_borrowed:
+            self.emitter.emit_line(f"if ({dest} != NULL) {{")
+            self.emitter.emit_inc_ref(dest, attr_rtype)
+            self.emitter.emit_line("}")
+
     def next_branch(self) -> Branch | None:
         if self.op_index + 1 < len(self.ops):
             next_op = self.ops[self.op_index + 1]

mypyc/ir/ops.py

@@ -799,6 +799,35 @@ def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_get_attr(self)
 
 
+class GetAttrNullable(RegisterOp):
+    """obj.attr (for a native object) - allows NULL without raising AttributeError
+
+    This is used for spill targets where NULL indicates the non-return path was taken.
+    Unlike GetAttr, this won't raise AttributeError when the attribute is NULL.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, obj: Value, attr: str, line: int, *, borrow: bool = False) -> None:
+        super().__init__(line)
+        self.obj = obj
+        self.attr = attr
+        assert isinstance(obj.type, RInstance), "Attribute access not supported: %s" % obj.type
+        self.class_type = obj.type
+        attr_type = obj.type.attr_type(attr)
+        self.type = attr_type
+        self.is_borrowed = borrow and attr_type.is_refcounted
+
+    def sources(self) -> list[Value]:
+        return [self.obj]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.obj,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_get_attr_nullable(self)
+
+
 class SetAttr(RegisterOp):
     """obj.attr = src (for a native object)
 
@@ -1728,6 +1757,10 @@ def visit_load_literal(self, op: LoadLiteral) -> T:
     def visit_get_attr(self, op: GetAttr) -> T:
         raise NotImplementedError
 
+    @abstractmethod
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> T:
+        raise NotImplementedError
+
     @abstractmethod
     def visit_set_attr(self, op: SetAttr) -> T:
         raise NotImplementedError

mypyc/ir/pprint.py

@@ -28,6 +28,7 @@
     FloatNeg,
     FloatOp,
     GetAttr,
+    GetAttrNullable,
     GetElementPtr,
     Goto,
     IncRef,
@@ -128,6 +129,9 @@ def visit_load_literal(self, op: LoadLiteral) -> str:
     def visit_get_attr(self, op: GetAttr) -> str:
         return self.format("%r = %s%r.%s", op, self.borrow_prefix(op), op.obj, op.attr)
 
+    def visit_get_attr_nullable(self, op: GetAttrNullable) -> str:
+        return self.format("%r = %s%r.%s?", op, self.borrow_prefix(op), op.obj, op.attr)
+
     def borrow_prefix(self, op: Op) -> str:
         if op.is_borrowed:
             return "borrow "

mypyc/irbuild/builder.py

@@ -72,6 +72,7 @@
     Branch,
     ComparisonOp,
     GetAttr,
+    GetAttrNullable,
     InitStatic,
     Integer,
     IntOp,
@@ -708,6 +709,15 @@ def read(
 
         assert False, "Unsupported lvalue: %r" % target
 
+    def read_nullable_attr(self, obj: Value, attr: str, line: int = -1) -> Value:
+        """Read an attribute that might be NULL without raising AttributeError.
+
+        This is used for reading spill targets in try/finally blocks where NULL
+        indicates the non-return path was taken.
+        """
+        assert isinstance(obj.type, RInstance) and obj.type.class_ir.is_ext_class
+        return self.add(GetAttrNullable(obj, attr, line))
+
     def assign(self, target: Register | AssignmentTarget, rvalue_reg: Value, line: int) -> None:
         if isinstance(target, Register):
             self.add(Assign(target, self.coerce_rvalue(rvalue_reg, target.type, line)))

mypyc/irbuild/statement.py

@@ -46,6 +46,7 @@
     YieldExpr,
     YieldFromExpr,
 )
+from mypyc.common import TEMP_ATTR_NAME
 from mypyc.ir.ops import (
     NAMESPACE_MODULE,
     NO_TRACEBACK_LINE_NO,
@@ -653,10 +654,15 @@ def try_finally_resolve_control(
     if ret_reg:
         builder.activate_block(rest)
         return_block, rest = BasicBlock(), BasicBlock()
-        builder.add(Branch(builder.read(ret_reg), rest, return_block, Branch.IS_ERROR))
+        # For spill targets in try/finally, use nullable read to avoid AttributeError
+        if isinstance(ret_reg, AssignmentTargetAttr) and ret_reg.attr.startswith(TEMP_ATTR_NAME):
+            ret_val = builder.read_nullable_attr(ret_reg.obj, ret_reg.attr, -1)
+        else:
+            ret_val = builder.read(ret_reg)
+        builder.add(Branch(ret_val, rest, return_block, Branch.IS_ERROR))
 
         builder.activate_block(return_block)
-        builder.nonlocal_control[-1].gen_return(builder, builder.read(ret_reg), -1)
+        builder.nonlocal_control[-1].gen_return(builder, ret_val, -1)
 
     # TODO: handle break/continue
     builder.activate_block(rest)