guppylang-internals 0.24.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

guppylang_internals/compiler/modifier_compiler.py

@@ -0,0 +1,174 @@
+"""Hugr generation for modifiers."""
+
+from hugr import Wire, ops
+from hugr import tys as ht
+
+from guppylang_internals.ast_util import get_type
+from guppylang_internals.checker.modifier_checker import non_copyable_front_others_back
+from guppylang_internals.compiler.cfg_compiler import compile_cfg
+from guppylang_internals.compiler.core import CompilerContext, DFContainer
+from guppylang_internals.compiler.expr_compiler import ExprCompiler
+from guppylang_internals.nodes import CheckedModifiedBlock, PlaceNode
+from guppylang_internals.std._internal.compiler.array import (
+    array_new,
+    array_to_std_array,
+    standard_array_type,
+    std_array_to_array,
+    unpack_array,
+)
+from guppylang_internals.std._internal.compiler.tket_exts import MODIFIER_EXTENSION
+from guppylang_internals.tys.builtin import int_type, is_array_type
+from guppylang_internals.tys.ty import InputFlags
+
+
+def compile_modified_block(
+    modified_block: CheckedModifiedBlock,
+    dfg: DFContainer,
+    ctx: CompilerContext,
+    expr_compiler: ExprCompiler,
+) -> Wire:
+    DAGGER_OP_NAME = "DaggerModifier"
+    CONTROL_OP_NAME = "ControlModifier"
+    POWER_OP_NAME = "PowerModifier"
+
+    dagger_op_def = MODIFIER_EXTENSION.get_op(DAGGER_OP_NAME)
+    control_op_def = MODIFIER_EXTENSION.get_op(CONTROL_OP_NAME)
+    power_op_def = MODIFIER_EXTENSION.get_op(POWER_OP_NAME)
+
+    body_ty = modified_block.ty
+    # TODO: Shouldn't this be `to_hugr_poly` since it can contain
+    # a variable with a generic type?
+    hugr_ty = body_ty.to_hugr(ctx)
+    in_out_ht = [
+        fn_inp.ty.to_hugr(ctx)
+        for fn_inp in body_ty.inputs
+        if InputFlags.Inout in fn_inp.flags and InputFlags.Comptime not in fn_inp.flags
+    ]
+    other_in_ht = [
+        fn_inp.ty.to_hugr(ctx)
+        for fn_inp in body_ty.inputs
+        if InputFlags.Inout not in fn_inp.flags
+        and InputFlags.Comptime not in fn_inp.flags
+    ]
+    in_out_arg = ht.ListArg([t.type_arg() for t in in_out_ht])
+    other_in_arg = ht.ListArg([t.type_arg() for t in other_in_ht])
+
+    func_builder = dfg.builder.module_root_builder().define_function(
+        str(modified_block), hugr_ty.input, hugr_ty.output
+    )
+
+    # compile body
+    cfg = compile_cfg(modified_block.cfg, func_builder, func_builder.inputs(), ctx)
+    func_builder.set_outputs(*cfg)
+
+    # LoadFunc
+    call = dfg.builder.load_function(func_builder, hugr_ty)
+
+    # Function inputs
+    captured = [v for v, _ in modified_block.captured.values()]
+    captured = non_copyable_front_others_back(captured)
+    args = [dfg[v] for v in captured]
+
+    # Apply modifiers
+    if modified_block.has_dagger():
+        dagger_ty = ht.FunctionType([hugr_ty], [hugr_ty])
+        call = dfg.builder.add_op(
+            ops.ExtOp(
+                dagger_op_def,
+                dagger_ty,
+                [in_out_arg, other_in_arg],
+            ),
+            call,
+        )
+    if modified_block.has_power():
+        power_ty = ht.FunctionType([hugr_ty, int_type().to_hugr(ctx)], [hugr_ty])
+        for power in modified_block.power:
+            num = expr_compiler.compile(power.iter, dfg)
+            call = dfg.builder.add_op(
+                ops.ExtOp(
+                    power_op_def,
+                    power_ty,
+                    [in_out_arg, other_in_arg],
+                ),
+                call,
+                num,
+            )
+    qubit_num_args = []
+    if modified_block.has_control():
+        for control in modified_block.control:
+            assert control.qubit_num is not None
+            qubit_num: ht.TypeArg
+            if isinstance(control.qubit_num, int):
+                qubit_num = ht.BoundedNatArg(control.qubit_num)
+            else:
+                qubit_num = control.qubit_num.to_arg().to_hugr(ctx)
+            qubit_num_args.append(qubit_num)
+            std_array = standard_array_type(ht.Qubit, qubit_num)
+
+            # control operator
+            input_fn_ty = hugr_ty
+            output_fn_ty = ht.FunctionType(
+                [std_array, *hugr_ty.input], [std_array, *hugr_ty.output]
+            )
+            op = ops.ExtOp(
+                control_op_def,
+                ht.FunctionType([input_fn_ty], [output_fn_ty]),
+                [qubit_num, in_out_arg, other_in_arg],
+            )
+            call = dfg.builder.add_op(op, call)
+            # update types
+            in_out_arg = ht.ListArg([std_array.type_arg(), *in_out_arg.elems])
+            hugr_ty = output_fn_ty
+
+    # Prepare control arguments
+    ctrl_args: list[Wire] = []
+    for i, control in enumerate(modified_block.control):
+        if is_array_type(get_type(control.ctrl[0])):
+            control_array = expr_compiler.compile(control.ctrl[0], dfg)
+            control_array = dfg.builder.add_op(
+                array_to_std_array(ht.Qubit, qubit_num_args[i]), control_array
+            )
+            ctrl_args.append(control_array)
+        else:
+            cs = [expr_compiler.compile(c, dfg) for c in control.ctrl]
+            control_array = dfg.builder.add_op(
+                array_new(ht.Qubit, len(control.ctrl)), *cs
+            )
+            control_array = dfg.builder.add_op(
+                array_to_std_array(ht.Qubit, qubit_num_args[i]), *control_array
+            )
+            ctrl_args.append(control_array)
+
+    # Call
+    call = dfg.builder.add_op(
+        ops.CallIndirect(),
+        call,
+        *ctrl_args,
+        *args,
+    )
+    outports = iter(call)
+
+    # Unpack controls
+    for i, control in enumerate(modified_block.control):
+        outport = next(outports)
+        if is_array_type(get_type(control.ctrl[0])):
+            control_array = dfg.builder.add_op(
+                std_array_to_array(ht.Qubit, qubit_num_args[i]), outport
+            )
+            c = control.ctrl[0]
+            assert isinstance(c, PlaceNode)
+            dfg[c.place] = control_array
+        else:
+            control_array = dfg.builder.add_op(
+                std_array_to_array(ht.Qubit, qubit_num_args[i]), outport
+            )
+            unpacked = unpack_array(dfg.builder, control_array)
+            for c, new_c in zip(control.ctrl, unpacked, strict=False):
+                assert isinstance(c, PlaceNode)
+                dfg[c.place] = new_c
+
+    for arg in captured:
+        if InputFlags.Inout in arg.flags:
+            dfg[arg] = next(outports)
+
+    return call

guppylang_internals/compiler/stmt_compiler.py

@@ -2,7 +2,6 @@ import ast
 import functools
 from collections.abc import Sequence
 
-import hugr.tys as ht
 from hugr import Wire, ops
 from hugr.build.dfg import DfBase
 
@@ -18,6 +17,7 @@ from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.nodes import (
     ArrayUnpack,
+    CheckedModifiedBlock,
     CheckedNestedFunctionDef,
     IterableUnpack,
     PlaceNode,
@@ -120,8 +120,9 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
                 ports[len(left) : -len(right)] if right else ports[len(left) :]
             )
             elt = get_element_type(array_ty).to_hugr(self.ctx)
-            opts = [self.builder.add_op(ops.Some(elt), p) for p in starred_ports]
-            array = self.builder.add_op(array_new(ht.Option(elt), len(opts)), *opts)
+            array = self.builder.add_op(
+                array_new(elt, len(starred_ports)), *starred_ports
+            )
             self._assign(starred, array)
 
     @_assign.register
@@ -130,7 +131,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
         # Given an assignment pattern `left, *starred, right`, pop from the left and
         # right, leaving us with the starred array in the middle
         length = lhs.length
-        opt_elt_ty = ht.Option(lhs.elt_type.to_hugr(self.ctx))
+        elt_ty = lhs.elt_type.to_hugr(self.ctx)
 
         def pop(
             array: Wire, length: int, pats: list[ast.expr], from_left: bool
@@ -141,10 +142,9 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             elts = []
             for i in range(num_pats):
                 res = self.builder.add_op(
-                    array_pop(opt_elt_ty, length - i, from_left), array
+                    array_pop(elt_ty, length - i, from_left), array
                 )
-                [elt_opt, array] = build_unwrap(self.builder, res, err)
-                [elt] = build_unwrap(self.builder, elt_opt, err)
+                [elt, array] = build_unwrap(self.builder, res, err)
                 elts.append(elt)
             # Assign elements to the given patterns
             for pat, elt in zip(
@@ -164,7 +164,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             self._assign(lhs.pattern.starred, array)
         else:
             assert length == 0
-            self.builder.add_op(array_discard_empty(opt_elt_ty), array)
+            self.builder.add_op(array_discard_empty(elt_ty), array)
 
     @_assign.register
     def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
@@ -221,3 +221,10 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
         var = Variable(node.name, node.ty, node)
         loaded_func = compile_local_func_def(node, self.dfg, self.ctx)
         self.dfg[var] = loaded_func
+
+    def visit_CheckedModifiedBlock(self, node: CheckedModifiedBlock) -> None:
+        from guppylang_internals.compiler.modifier_compiler import (
+            compile_modified_block,
+        )
+
+        compile_modified_block(node, self.dfg, self.ctx, self.expr_compiler)

guppylang_internals/definition/custom.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, ClassVar
 from hugr import Wire, ops
 from hugr import tys as ht
 from hugr.build.dfg import DfBase
+from hugr.std.collections.borrow_array import EXTENSION as BORROW_ARRAY_EXTENSION
 
 from guppylang_internals.ast_util import (
     AstNode,
@@ -23,6 +24,7 @@ from guppylang_internals.compiler.core import (
     DFContainer,
     GlobalConstId,
     partially_monomorphize_args,
+    qualified_name,
 )
 from guppylang_internals.definition.common import ParsableDef
 from guppylang_internals.definition.value import CallReturnWires, CompiledCallableDef
@@ -486,7 +488,39 @@ class NoopCompiler(CustomCallCompiler):
 
 
 class CopyInoutCompiler(CustomInoutCallCompiler):
-    """Call compiler for functions that are noops but only want to borrow arguments."""
+    """Call compiler for functions that borrow one argument to copy it."""
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert len(self.ty.input) == 1
+        inp_ty = self.ty.input[0]
+        if inp_ty.type_bound() == ht.TypeBound.Linear:
+            (arg,) = args
+            copies = self._handle_affine_type(inp_ty, arg)
+            return CallReturnWires(
+                regular_returns=[copies[0]], inout_returns=[copies[1]]
+            )
         return CallReturnWires(regular_returns=args, inout_returns=args)
+
+    # Affine types in Guppy backed by a linear Hugr type need to be copied explicitly.
+    # TODO: Handle affine extension types more generally (borrow arrays are currently
+    # the only case).
+    def _handle_affine_type(self, ty: ht.Type, arg: Wire) -> list[Wire]:
+        match ty:
+            case ht.ExtType(type_def=type_def, args=type_args):
+                if qualified_name(type_def) == qualified_name(
+                    BORROW_ARRAY_EXTENSION.get_type("borrow_array")
+                ):
+                    assert len(type_args) == 2
+                    # Manually instantiate here to avoid circular import and use
+                    # type args directly.
+                    clone_op = BORROW_ARRAY_EXTENSION.get_op("clone").instantiate(
+                        type_args,
+                        ht.FunctionType(self.ty.input, self.ty.output),
+                    )
+                    return list(self.builder.add_op(clone_op, arg))
+            case _:
+                pass
+        raise InternalGuppyError(
+            f"Type `{ty}` needs an explicit handler in the `copy` compiler as "
+            "it is an affine Guppy type backed by a linear Hugr type."
+        )

guppylang_internals/definition/declaration.py

@@ -13,7 +13,7 @@ from guppylang_internals.checker.func_checker import check_signature
 from guppylang_internals.compiler.core import (
     CompilerContext,
     DFContainer,
-    requires_monomorphization,
+    require_monomorphization,
 )
 from guppylang_internals.definition.common import CompilableDef, ParsableDef
 from guppylang_internals.definition.function import (
@@ -72,9 +72,8 @@ class RawFunctionDecl(ParsableDef):
         if not has_empty_body(func_ast):
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
         # Make sure we won't need monomorphization to compile this declaration
-        for param in ty.params:
-            if requires_monomorphization(param):
-                raise GuppyError(MonomorphizeError(func_ast, self.name, param))
+        if mono_params := require_monomorphization(ty.params):
+            raise GuppyError(MonomorphizeError(func_ast, self.name, mono_params.pop()))
         return CheckedFunctionDecl(
             self.id,
             self.name,

guppylang_internals/definition/parameter.py

@@ -38,14 +38,19 @@ class ParamDef(Definition):
 class TypeVarDef(ParamDef, CompiledDef):
     """A type variable definition."""
 
-    must_be_copyable: bool
-    must_be_droppable: bool
+    copyable: bool
+    droppable: bool
 
     description: str = field(default="type variable", init=False)
 
     def to_param(self, idx: int) -> TypeParam:
         """Creates a parameter from this definition."""
-        return TypeParam(idx, self.name, self.must_be_copyable, self.must_be_droppable)
+        return TypeParam(
+            idx,
+            self.name,
+            must_be_copyable=self.copyable,
+            must_be_droppable=self.droppable,
+        )
 
 
 @dataclass(frozen=True)

guppylang_internals/definition/pytket_circuits.py

@@ -46,7 +46,6 @@ from guppylang_internals.std._internal.compiler.array import (
     array_new,
     array_unpack,
 )
-from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, make_opaque
 from guppylang_internals.tys.builtin import array_type, bool_type, float_type
 from guppylang_internals.tys.subst import Inst, Subst
@@ -195,17 +194,9 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     # them into separate wires.
                     for i, q_reg in enumerate(self.input_circuit.q_registers):
                         reg_wire = outer_func.inputs()[i]
-                        opt_elem_wires = outer_func.add_op(
-                            array_unpack(ht.Option(ht.Qubit), q_reg.size), reg_wire
+                        elem_wires = outer_func.add_op(
+                            array_unpack(ht.Qubit, q_reg.size), reg_wire
                         )
-                        elem_wires = [
-                            build_unwrap(
-                                outer_func,
-                                opt_elem,
-                                "Internal error: unwrapping of array element failed",
-                            )
-                            for opt_elem in opt_elem_wires
-                        ]
                         input_list.extend(elem_wires)
 
                 else:
@@ -219,7 +210,8 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 ]
 
                 # Symbolic parameters (if present) get passed after qubits and bools.
-                has_params = len(self.input_circuit.free_symbols()) != 0
+                num_params = len(self.input_circuit.free_symbols())
+                has_params = num_params != 0
                 if has_params and "TKET1.input_parameters" not in hugr_func.metadata:
                     raise InternalGuppyError(
                         "Parameter metadata is missing from pytket circuit HUGR"
@@ -230,26 +222,17 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 if has_params:
                     lex_params: list[Wire] = list(outer_func.inputs()[offset:])
                     if self.use_arrays:
-                        opt_param_wires = outer_func.add_op(
+                        unpack_result = outer_func.add_op(
                             array_unpack(
-                                ht.Option(ht.Tuple(float_type().to_hugr(ctx))),
-                                q_reg.size,
+                                ht.Tuple(float_type().to_hugr(ctx)), num_params
                             ),
                             lex_params[0],
                         )
-                        lex_params = [
-                            build_unwrap(
-                                outer_func,
-                                opt_param,
-                                "Internal error: unwrapping of array element failed",
-                            )
-                            for opt_param in opt_param_wires
-                        ]
+                        lex_params = list(unpack_result)
                     param_order = cast(
                         list[str], hugr_func.metadata["TKET1.input_parameters"]
                     )
                     lex_names = sorted(param_order)
-                    assert len(lex_names) == len(lex_params)
                     name_to_param = dict(zip(lex_names, lex_params, strict=True))
                     angle_wires = [name_to_param[name] for name in param_order]
                     # Need to convert all angles to floats.
@@ -280,34 +263,23 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 ]
 
                 if self.use_arrays:
-
-                    def pack(elems: list[Wire], elem_ty: ht.Type, length: int) -> Wire:
-                        elem_opts = [
-                            outer_func.add_op(ops.Some(elem_ty), elem) for elem in elems
-                        ]
-                        return outer_func.add_op(
-                            array_new(ht.Option(elem_ty), length), *elem_opts
-                        )
-
                     array_wires: list[Wire] = []
                     wire_idx = 0
                     # First pack bool results into an array.
                     for c_reg in self.input_circuit.c_registers:
                         array_wires.append(
-                            pack(
-                                wires[wire_idx : wire_idx + c_reg.size],
-                                OpaqueBool,
-                                c_reg.size,
+                            outer_func.add_op(
+                                array_new(OpaqueBool, c_reg.size),
+                                *wires[wire_idx : wire_idx + c_reg.size],
                             )
                         )
                         wire_idx = wire_idx + c_reg.size
                     # Then the borrowed qubits also need to be put back into arrays.
                     for q_reg in self.input_circuit.q_registers:
                         array_wires.append(
-                            pack(
-                                wires[wire_idx : wire_idx + q_reg.size],
-                                ht.Qubit,
-                                q_reg.size,
+                            outer_func.add_op(
+                                array_new(ht.Qubit, q_reg.size),
+                                *wires[wire_idx : wire_idx + q_reg.size],
                             )
                         )
                         wire_idx = wire_idx + q_reg.size

guppylang_internals/definition/struct.py

@@ -131,10 +131,13 @@ class RawStructDef(TypeDef, ParsableDef):
             if cls_def.type_params:
                 first, last = cls_def.type_params[0], cls_def.type_params[-1]
                 params_span = Span(to_span(first).start, to_span(last).end)
-                params = [
-                    parse_parameter(node, idx, globals)
-                    for idx, node in enumerate(cls_def.type_params)
-                ]
+                param_vars_mapping: dict[str, Parameter] = {}
+                for idx, param_node in enumerate(cls_def.type_params):
+                    param = parse_parameter(
+                        param_node, idx, globals, param_vars_mapping
+                    )
+                    param_vars_mapping[param.name] = param
+                    params.append(param)
 
         # The only base we allow is `Generic[...]` to specify generic parameters with
         # the legacy syntax

guppylang_internals/definition/ty.py

@@ -2,7 +2,7 @@ from abc import abstractmethod
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 
-from hugr import tys
+from hugr import tys as ht
 
 from guppylang_internals.ast_util import AstNode
 from guppylang_internals.definition.common import CompiledDef, Definition
@@ -42,8 +42,8 @@ class OpaqueTypeDef(TypeDef, CompiledDef):
     params: Sequence[Parameter]
     never_copyable: bool
     never_droppable: bool
-    to_hugr: Callable[[Sequence[Argument], ToHugrContext], tys.Type]
-    bound: tys.TypeBound | None = None
+    to_hugr: Callable[[Sequence[Argument], ToHugrContext], ht.Type]
+    bound: ht.TypeBound | None = None
 
     def check_instantiate(
         self, args: Sequence[Argument], loc: AstNode | None = None

guppylang_internals/experimental.py

@@ -90,3 +90,8 @@ def check_lists_enabled(loc: AstNode | None = None) -> None:
 def check_capturing_closures_enabled(loc: AstNode | None = None) -> None:
     if not EXPERIMENTAL_FEATURES_ENABLED:
         raise GuppyError(UnsupportedError(loc, "Capturing closures"))
+
+
+def check_modifiers_enabled(loc: AstNode | None = None) -> None:
+    if not EXPERIMENTAL_FEATURES_ENABLED:
+        raise GuppyError(ExperimentalFeatureError(loc, "Modifiers"))

guppylang_internals/nodes.py

@@ -6,6 +6,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from guppylang_internals.ast_util import AstNode
+from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.const import Const
 from guppylang_internals.tys.subst import Inst
 from guppylang_internals.tys.ty import FunctionType, StructType, TupleType, Type
@@ -422,3 +423,126 @@ class CheckedNestedFunctionDef(ast.FunctionDef):
         self.cfg = cfg
         self.ty = ty
         self.captured = captured
+
+
+class Dagger(ast.expr):
+    """The dagger modifier"""
+
+    def __init__(self, node: ast.expr) -> None:
+        super().__init__(**node.__dict__)
+
+
+class Control(ast.Call):
+    """The control modifier"""
+
+    ctrl: list[ast.expr]
+    qubit_num: int | Const | None
+
+    _fields = ("ctrl",)
+
+    def __init__(self, node: ast.Call, ctrl: list[ast.expr]) -> None:
+        super().__init__(**node.__dict__)
+        self.ctrl = ctrl
+        self.qubit_num = None
+
+
+class Power(ast.expr):
+    """The power modifier"""
+
+    iter: ast.expr
+
+    _fields = ("iter",)
+
+    def __init__(self, node: ast.expr, iter: ast.expr) -> None:
+        super().__init__(**node.__dict__)
+        self.iter = iter
+
+
+Modifier = Dagger | Control | Power
+
+
+class ModifiedBlock(ast.With):
+    cfg: "CFG"
+    dagger: list[Dagger]
+    control: list[Control]
+    power: list[Power]
+
+    def __init__(self, cfg: "CFG", *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.cfg = cfg
+        self.dagger = []
+        self.control = []
+        self.power = []
+
+    def is_dagger(self) -> bool:
+        return len(self.dagger) % 2 == 1
+
+    def is_control(self) -> bool:
+        return len(self.control) > 0
+
+    def is_power(self) -> bool:
+        return len(self.power) > 0
+
+    def span_ctxt_manager(self) -> Span:
+        return Span(
+            to_span(self.items[0].context_expr).start,
+            to_span(self.items[-1].context_expr).end,
+        )
+
+    def push_modifier(self, modifier: Modifier) -> None:
+        """Pushes a modifier kind onto the modifier."""
+        if isinstance(modifier, Dagger):
+            self.dagger.append(modifier)
+        elif isinstance(modifier, Control):
+            self.control.append(modifier)
+        elif isinstance(modifier, Power):
+            self.power.append(modifier)
+        else:
+            raise TypeError(f"Unknown modifier: {modifier}")
+
+
+class CheckedModifiedBlock(ast.With):
+    def_id: "DefId"
+    cfg: "CheckedCFG[Place]"
+    dagger: list[Dagger]
+    control: list[Control]
+    power: list[Power]
+
+    #: The type of the body of With block.
+    ty: FunctionType
+    #: Mapping from names to variables captured in the body.
+    captured: Mapping[str, tuple["Variable", AstNode]]
+
+    def __init__(
+        self,
+        def_id: "DefId",
+        cfg: "CheckedCFG[Place]",
+        ty: FunctionType,
+        captured: Mapping[str, tuple["Variable", AstNode]],
+        dagger: list[Dagger],
+        control: list[Control],
+        power: list[Power],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.def_id = def_id
+        self.cfg = cfg
+        self.ty = ty
+        self.captured = captured
+        self.dagger = dagger
+        self.control = control
+        self.power = power
+
+    def __str__(self) -> str:
+        # generate a function name from the def_id
+        return f"__WithBlock__({self.def_id})"
+
+    def has_dagger(self) -> bool:
+        return len(self.dagger) % 2 == 1
+
+    def has_control(self) -> bool:
+        return any(len(c.ctrl) > 0 for c in self.control)
+
+    def has_power(self) -> bool:
+        return len(self.power) > 0