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

guppylang_internals/checker/func_checker.py

@@ -16,6 +16,7 @@ from guppylang_internals.cfg.builder import CFGBuilder
 from guppylang_internals.checker.cfg_checker import CheckedCFG, check_cfg
 from guppylang_internals.checker.core import Context, Globals, Place, Variable
 from guppylang_internals.checker.errors.generic import UnsupportedError
+from guppylang_internals.checker.unitary_checker import check_invalid_under_dagger
 from guppylang_internals.definition.common import DefId
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error, Help, Note
@@ -37,6 +38,7 @@ from guppylang_internals.tys.ty import (
     InputFlags,
     NoneType,
     Type,
+    UnitaryFlags,
     unify,
 )
 
@@ -134,12 +136,13 @@ def check_global_func_def(
     """Type checks a top-level function definition."""
     args = func_def.args.args
     returns_none = isinstance(ty.output, NoneType)
-    assert ty.input_names is not None
+    assert all(inp.name is not None for inp in ty.inputs)
 
-    cfg = CFGBuilder().build(func_def.body, returns_none, globals)
+    check_invalid_under_dagger(func_def, ty.unitary_flags)
+    cfg = CFGBuilder().build(func_def.body, returns_none, globals, ty.unitary_flags)
     inputs = [
-        Variable(x, inp.ty, loc, inp.flags, is_func_input=True)
-        for x, inp, loc in zip(ty.input_names, ty.inputs, args, strict=True)
+        Variable(cast(str, inp.name), inp.ty, loc, inp.flags, is_func_input=True)
+        for inp, loc in zip(ty.inputs, args, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
     ]
@@ -150,7 +153,9 @@ def check_global_func_def(
 
 
 def check_nested_func_def(
-    func_def: NestedFunctionDef, bb: BB, ctx: Context
+    func_def: NestedFunctionDef,
+    bb: BB,
+    ctx: Context,
 ) -> CheckedNestedFunctionDef:
     """Type checks a local (nested) function definition."""
     func_ty = check_signature(func_def, ctx.globals)
@@ -194,10 +199,8 @@ def check_nested_func_def(
 
     # Construct inputs for checking the body CFG
     inputs = [v for v, _ in captured.values()] + [
-        Variable(x, inp.ty, func_def.args.args[i], inp.flags, is_func_input=True)
-        for i, (x, inp) in enumerate(
-            zip(func_ty.input_names, func_ty.inputs, strict=True)
-        )
+        Variable(cast(str, inp.name), inp.ty, arg, inp.flags, is_func_input=True)
+        for arg, inp in zip(func_def.args.args, func_ty.inputs, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
     ]
@@ -238,7 +241,10 @@ def check_nested_func_def(
 
 
 def check_signature(
-    func_def: ast.FunctionDef, globals: Globals, def_id: DefId | None = None
+    func_def: ast.FunctionDef,
+    globals: Globals,
+    def_id: DefId | None = None,
+    unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
 ) -> FunctionType:
     """Checks the signature of a function definition and returns the corresponding
     Guppy type.
@@ -276,7 +282,7 @@ def check_signature(
     param_var_mapping: dict[str, Parameter] = {}
     if sys.version_info >= (3, 12):
         for i, param_node in enumerate(func_def.type_params):
-            param = parse_parameter(param_node, i, globals)
+            param = parse_parameter(param_node, i, globals, param_var_mapping)
             param_var_mapping[param.name] = param
 
     # Figure out if this is a method
@@ -286,7 +292,6 @@ def check_signature(
         assert isinstance(self_defn, TypeDef)
 
     inputs = []
-    input_names = []
     ctx = TypeParsingCtx(globals, param_var_mapping, allow_free_vars=True)
     for i, inp in enumerate(func_def.args.args):
         # Special handling for `self` arguments. Note that `__new__` is excluded here
@@ -300,13 +305,12 @@ def check_signature(
                 raise GuppyError(MissingArgAnnotationError(inp))
             input = parse_function_arg_annotation(ty_ast, inp.arg, ctx)
         inputs.append(input)
-        input_names.append(inp.arg)
     output = type_from_ast(func_def.returns, ctx)
     return FunctionType(
         inputs,
         output,
-        input_names,
         sorted(param_var_mapping.values(), key=lambda v: v.idx),
+        unitary_flags=unitary_flags,
     )
 
 

guppylang_internals/checker/linearity_checker.py

@@ -52,6 +52,7 @@ from guppylang_internals.error import GuppyError, GuppyTypeError
 from guppylang_internals.nodes import (
     AnyCall,
     BarrierExpr,
+    CheckedModifiedBlock,
     CheckedNestedFunctionDef,
     DesugaredArrayComp,
     DesugaredGenerator,
@@ -62,7 +63,6 @@ from guppylang_internals.nodes import (
     LocalCall,
     PartialApply,
     PlaceNode,
-    ResultExpr,
     StateResultExpr,
     SubscriptAccessAndDrop,
     TensorCall,
@@ -73,7 +73,6 @@ from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
     InputFlags,
-    NoneType,
     StructType,
     TupleType,
     Type,
@@ -450,13 +449,6 @@ class BBLinearityChecker(ast.NodeVisitor):
         self._visit_call_args(node.func_ty, node)
         self._reassign_inout_args(node.func_ty, node)
 
-    def visit_ResultExpr(self, node: ResultExpr) -> None:
-        ty = get_type(node.value)
-        flag = InputFlags.Inout if not ty.copyable else InputFlags.NoFlags
-        func_ty = FunctionType([FuncInput(ty, flag)], NoneType())
-        self._visit_call_args(func_ty, node)
-        self._reassign_inout_args(func_ty, node)
-
     def visit_StateResultExpr(self, node: StateResultExpr) -> None:
         self._visit_call_args(node.func_ty, node)
         self._reassign_inout_args(node.func_ty, node)
@@ -581,7 +573,7 @@ class BBLinearityChecker(ast.NodeVisitor):
             # can feed them through the loop. Note that we could also use non-local
             # edges, but we can't handle them in lower parts of the stack yet :/
             # TODO: Reinstate use of non-local edges.
-            #  See https://github.com/CQCL/guppylang/issues/963
+            #  See https://github.com/quantinuum/guppylang/issues/963
             gen.used_outer_places = []
             for x, use in inner_scope.used_parent.items():
                 place = inner_scope[x]
@@ -621,6 +613,70 @@ class BBLinearityChecker(ast.NodeVisitor):
             elif not place.ty.copyable:
                 raise GuppyTypeError(ComprAlreadyUsedError(use.node, place, use.kind))
 
+    def visit_CheckedModifiedBlock(self, node: CheckedModifiedBlock) -> None:
+        # Linear usage of variables in a with statement
+        # ```
+        # with control(c1, c2, ...):
+        #   body(q1, q2, ...) # captured variables
+        # ````
+        # is the same as to assume that this is a function call
+        # `WithCtrl(q1, q2, ..., c1, c2, ...)`
+        # where `WithCtrl` is a function that takes the control as mutable references.
+        # Therefore, we apply the same linearity rules as for function arguments.
+        # ```
+        # def WithCtrl(q1, q2, ..., c1, c2, ...):
+        #   body(q1, q2, ...)
+        # ```
+
+        # check control
+        for ctrl in node.control:
+            for arg in ctrl.ctrl:
+                if isinstance(arg, PlaceNode):
+                    self.visit_PlaceNode(arg, use_kind=UseKind.BORROW, is_call_arg=None)
+                else:
+                    ty = get_type(arg)
+                    unnamed_err = UnnamedExprNotUsedError(arg, ty)
+                    unnamed_err.add_sub_diagnostic(UnnamedExprNotUsedError.Fix(None))
+                    raise GuppyTypeError(unnamed_err)
+
+        # check power
+        for power in node.power:
+            if isinstance(power.iter, PlaceNode):
+                self.visit_PlaceNode(
+                    power.iter, use_kind=UseKind.CONSUME, is_call_arg=None
+                )
+            else:
+                self.visit(power.iter)
+
+        # check captured variables
+        for var, use in node.captured.values():
+            for place in leaf_places(var):
+                use_kind = (
+                    UseKind.BORROW if InputFlags.Inout in var.flags else UseKind.CONSUME
+                )
+
+                x = place.id
+                if (prev_use := self.scope.used(x)) and not place.ty.copyable:
+                    used_err = AlreadyUsedError(use, place, use_kind)
+                    used_err.add_sub_diagnostic(
+                        AlreadyUsedError.PrevUse(prev_use.node, prev_use.kind)
+                    )
+                    if has_explicit_copy(place.ty):
+                        used_err.add_sub_diagnostic(AlreadyUsedError.MakeCopy(None))
+                    raise GuppyError(used_err)
+                self.scope.use(x, node, use_kind)
+
+        # reassign controls
+        for ctrl in node.control:
+            for arg in ctrl.ctrl:
+                assert isinstance(arg, PlaceNode)  # Checked above
+                self._reassign_single_inout_arg(arg.place, arg.place.defined_at or arg)
+
+        # reassign captured variables
+        for var, use in node.captured.values():
+            if InputFlags.Inout in var.flags:
+                self._reassign_single_inout_arg(var, var.defined_at or use)
+
 
 def leaf_places(place: Place) -> Iterator[Place]:
     """Returns all leaf descendant projections of a place."""
@@ -815,6 +871,7 @@ def check_cfg_linearity(
     result_cfg.maybe_ass_before = {
         checked[bb]: cfg.maybe_ass_before[bb] for bb in cfg.bbs
     }
+    result_cfg.unitary_flags = cfg.unitary_flags
     for bb in cfg.bbs:
         checked[bb].predecessors = [checked[pred] for pred in bb.predecessors]
         checked[bb].successors = [checked[succ] for succ in bb.successors]

guppylang_internals/checker/modifier_checker.py

@@ -0,0 +1,120 @@
+"""Type checking code for modifiers."""
+
+import ast
+
+from guppylang_internals.ast_util import loop_in_ast, with_loc
+from guppylang_internals.cfg.bb import BB
+from guppylang_internals.checker.cfg_checker import check_cfg
+from guppylang_internals.checker.core import Context, Variable
+from guppylang_internals.checker.errors.generic import InvalidUnderDagger
+from guppylang_internals.definition.common import DefId
+from guppylang_internals.error import GuppyError
+from guppylang_internals.nodes import CheckedModifiedBlock, ModifiedBlock
+from guppylang_internals.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    Type,
+)
+
+
+def check_modified_block(
+    modified_block: ModifiedBlock, bb: BB, ctx: Context
+) -> CheckedModifiedBlock:
+    """Type checks a modifier definition."""
+    cfg = modified_block.cfg
+
+    # Find captured variables
+    parent_cfg = bb.containing_cfg
+    def_ass_before = ctx.locals.keys()
+    maybe_ass_before = def_ass_before | parent_cfg.maybe_ass_before[bb]
+
+    cfg.analyze(def_ass_before, maybe_ass_before, [])
+    captured = {
+        x: (_set_inout_if_non_copyable(ctx.locals[x]), using_bb.vars.used[x])
+        for x, using_bb in cfg.live_before[cfg.entry_bb].items()
+        if x in ctx.locals
+    }
+
+    # We do not allow any assignments if it is daggered.
+    if modified_block.is_dagger():
+        for stmt in modified_block.body:
+            loops = loop_in_ast(stmt)
+            if len(loops) != 0:
+                loop = next(iter(loops))
+                err = InvalidUnderDagger(loop, "Loop")
+                err.add_sub_diagnostic(
+                    InvalidUnderDagger.Dagger(modified_block.span_ctxt_manager())
+                )
+                raise GuppyError(err)
+
+        for cfg_bb in cfg.bbs:
+            if cfg_bb.vars.assigned:
+                _, v = next(iter(cfg_bb.vars.assigned.items()))
+                err = InvalidUnderDagger(v, "Assignment")
+                err.add_sub_diagnostic(
+                    InvalidUnderDagger.Dagger(modified_block.span_ctxt_manager())
+                )
+                raise GuppyError(err)
+
+    # The other checks are done in unitary checking.
+    # e.g. call to non-unitary function in a unitary modifier.
+
+    # Construct inputs for checking the body CFG
+    inputs = [v for v, _ in captured.values()]
+    inputs = non_copyable_front_others_back(inputs)
+    def_id = DefId.fresh()
+    globals = ctx.globals
+
+    # TODO: Ad hoc name for the new function
+    # This name could be printed in error messages, for example,
+    # when the linearity checker fails in the modifier body
+    checked_cfg = check_cfg(cfg, inputs, NoneType(), {}, "__modified__()", globals)
+    func_ty = check_modified_block_signature(modified_block, checked_cfg.input_tys)
+
+    checked_modifier = CheckedModifiedBlock(
+        def_id,
+        checked_cfg,
+        func_ty,
+        captured,
+        modified_block.dagger,
+        modified_block.control,
+        modified_block.power,
+        **dict(ast.iter_fields(modified_block)),
+    )
+    return with_loc(modified_block, checked_modifier)
+
+
+def _set_inout_if_non_copyable(var: Variable) -> Variable:
+    """Set the `inout` flag if the variable is non-copyable."""
+    if not var.ty.copyable:
+        return var.add_flags(InputFlags.Inout)
+    else:
+        return var
+
+
+def check_modified_block_signature(
+    modified_block: ModifiedBlock, input_tys: list[Type]
+) -> FunctionType:
+    """Check and create the signature of a function definition for a body
+    of a `With` block."""
+    unitary_flags = modified_block.flags()
+
+    func_ty = FunctionType(
+        [
+            FuncInput(t, InputFlags.Inout if not t.copyable else InputFlags.NoFlags)
+            for t in input_tys
+        ],
+        NoneType(),
+        unitary_flags=unitary_flags,
+    )
+    return func_ty
+
+
+def non_copyable_front_others_back(v: list[Variable]) -> list[Variable]:
+    """Reorder variables so that linear ones come first, preserving the relative order
+    of linear and non-linear variables."""
+    linear_vars = [x for x in v if not x.ty.copyable]
+    non_linear_vars = [x for x in v if x.ty.copyable]
+    return linear_vars + non_linear_vars

guppylang_internals/checker/stmt_checker.py

@@ -42,7 +42,9 @@ from guppylang_internals.checker.errors.type_errors import (
     MissingReturnValueError,
     StarredTupleUnpackError,
     TypeInferenceError,
+    TypeMismatchError,
     UnpackableError,
+    WrongNumberOfArgsError,
     WrongNumberOfUnpacksError,
 )
 from guppylang_internals.checker.expr_checker import (
@@ -58,6 +60,7 @@ from guppylang_internals.nodes import (
     DesugaredArrayComp,
     IterableUnpack,
     MakeIter,
+    ModifiedBlock,
     NestedFunctionDef,
     PlaceNode,
     TupleUnpack,
@@ -73,13 +76,15 @@ from guppylang_internals.tys.builtin import (
     is_sized_iter_type,
     nat_type,
 )
-from guppylang_internals.tys.const import ConstValue
+from guppylang_internals.tys.const import ConstValue, ExistentialConstVar
 from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.qubit import is_qubit_ty, qubit_ty
 from guppylang_internals.tys.subst import Subst
 from guppylang_internals.tys.ty import (
     ExistentialTypeVar,
     FunctionType,
     NoneType,
+    NumericType,
     StructType,
     TupleType,
     Type,
@@ -398,6 +403,48 @@ class StmtChecker(AstVisitor[BBStatement]):
         self.ctx.locals[func_def.name] = Variable(func_def.name, func_def.ty, func_def)
         return func_def
 
+    def visit_ModifiedBlock(self, node: ModifiedBlock) -> ast.stmt:
+        from guppylang_internals.checker.modifier_checker import check_modified_block
+
+        if not self.bb:
+            raise InternalGuppyError("BB required to check with block!")
+
+        # check the body of the modified block
+        modified_block = check_modified_block(node, self.bb, self.ctx)
+
+        # check the arguments of the control and power.
+        for control in modified_block.control:
+            ctrl = control.ctrl
+            # This case is handled during CFG construction.
+            assert len(ctrl) > 0
+            ctrl[0], ty = self._synth_expr(ctrl[0])
+
+            if is_array_type(ty):
+                if len(ctrl) > 1:
+                    span = Span(to_span(control.func).end, to_span(control).end)
+                    raise GuppyError(WrongNumberOfArgsError(span, 1, len(control.args)))
+                element_ty = get_element_type(ty)
+                if not is_qubit_ty(element_ty):
+                    n = ExistentialConstVar.fresh(
+                        "n", NumericType(NumericType.Kind.Nat)
+                    )
+                    dummy_array_ty = array_type(qubit_ty(), n)
+                    raise GuppyTypeError(TypeMismatchError(ctrl[0], dummy_array_ty, ty))
+                control.qubit_num = get_array_length(ty)
+            else:
+                for i in range(len(ctrl)):
+                    ctrl[i], subst = self._check_expr(ctrl[i], qubit_ty())
+                    assert len(subst) == 0
+                control.qubit_num = len(ctrl)
+
+        for power in node.power:
+            power.iter, subst = self._check_expr(
+                power.iter, NumericType(NumericType.Kind.Nat)
+            )
+            assert len(subst) == 0
+
+        return modified_block
+
     def visit_If(self, node: ast.If) -> None:
         raise InternalGuppyError("Control-flow statement should not be present here.")
 

guppylang_internals/checker/unitary_checker.py

@@ -0,0 +1,132 @@
+import ast
+
+from guppylang_internals.ast_util import find_nodes, get_type, loop_in_ast
+from guppylang_internals.checker.cfg_checker import CheckedBB, CheckedCFG
+from guppylang_internals.checker.core import Place, contains_subscript
+from guppylang_internals.checker.errors.generic import (
+    InvalidUnderDagger,
+    UnsupportedError,
+)
+from guppylang_internals.definition.value import CallableDef
+from guppylang_internals.engine import ENGINE
+from guppylang_internals.error import GuppyError, GuppyTypeError
+from guppylang_internals.nodes import (
+    AnyCall,
+    BarrierExpr,
+    GlobalCall,
+    LocalCall,
+    PlaceNode,
+    StateResultExpr,
+    TensorCall,
+)
+from guppylang_internals.tys.errors import UnitaryCallError
+from guppylang_internals.tys.qubit import contain_qubit_ty
+from guppylang_internals.tys.ty import FunctionType, UnitaryFlags
+
+
+def check_invalid_under_dagger(
+    fn_def: ast.FunctionDef, unitary_flags: UnitaryFlags
+) -> None:
+    """Check that there are no invalid constructs in a daggered CFG.
+    This checker checks the case the UnitaryFlags is given by
+    annotation (i.e., not inferred from `with dagger:`).
+    """
+    if UnitaryFlags.Dagger not in unitary_flags:
+        return
+
+    for stmt in fn_def.body:
+        loops = loop_in_ast(stmt)
+        if len(loops) != 0:
+            loop = next(iter(loops))
+            err = InvalidUnderDagger(loop, "Loop")
+            raise GuppyError(err)
+            # Note: sub-diagnostic for dagger context is not available here
+
+        found = find_nodes(
+            lambda n: isinstance(n, ast.Assign | ast.AnnAssign | ast.AugAssign),
+            stmt,
+            {ast.FunctionDef},
+        )
+        if len(found) != 0:
+            assign = next(iter(found))
+            err = InvalidUnderDagger(assign, "Assignment")
+            raise GuppyError(err)
+
+
+class BBUnitaryChecker(ast.NodeVisitor):
+    """AST visitor that checks whether the modifiers (dagger, control, power)
+    are applicable."""
+
+    flags: UnitaryFlags
+
+    def check(self, bb: CheckedBB[Place], unitary_flags: UnitaryFlags) -> None:
+        self.flags = unitary_flags
+        for stmt in bb.statements:
+            self.visit(stmt)
+
+    def _check_classical_args(self, args: list[ast.expr]) -> bool:
+        for arg in args:
+            self.visit(arg)
+            if contain_qubit_ty(get_type(arg)):
+                return False
+        return True
+
+    def _check_call(self, node: AnyCall, ty: FunctionType) -> None:
+        classic = self._check_classical_args(node.args)
+        flag_ok = self.flags in ty.unitary_flags
+        if not classic and not flag_ok:
+            raise GuppyTypeError(
+                UnitaryCallError(node, self.flags & (~ty.unitary_flags))
+            )
+
+    def visit_GlobalCall(self, node: GlobalCall) -> None:
+        func = ENGINE.get_parsed(node.def_id)
+        assert isinstance(func, CallableDef)
+        self._check_call(node, func.ty)
+
+    def visit_LocalCall(self, node: LocalCall) -> None:
+        func = get_type(node.func)
+        assert isinstance(func, FunctionType)
+        self._check_call(node, func)
+
+    def visit_TensorCall(self, node: TensorCall) -> None:
+        self._check_call(node, node.tensor_ty)
+
+    def visit_BarrierExpr(self, node: BarrierExpr) -> None:
+        # Barrier is always allowed
+        pass
+
+    def visit_StateResultExpr(self, node: StateResultExpr) -> None:
+        # StateResult is always allowed
+        pass
+
+    def _check_assign(self, node: ast.Assign | ast.AnnAssign | ast.AugAssign) -> None:
+        if UnitaryFlags.Dagger in self.flags:
+            raise GuppyError(InvalidUnderDagger(node, "Assignment"))
+        if node.value is not None:
+            self.visit(node.value)
+
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+        self._check_assign(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        self._check_assign(node)
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> None:
+        self._check_assign(node)
+
+    def visit_PlaceNode(self, node: PlaceNode) -> None:
+        if UnitaryFlags.Dagger in self.flags and contains_subscript(node.place):
+            raise GuppyError(
+                UnsupportedError(node, "index access", True, "dagger context")
+            )
+
+
+def check_cfg_unitary(
+    cfg: CheckedCFG[Place],
+    unitary_flags: UnitaryFlags,
+) -> None:
+    """Checks that the given unitary flags are valid for a CFG."""
+    bb_checker = BBUnitaryChecker()
+    for bb in cfg.bbs:
+        bb_checker.check(bb, unitary_flags)

guppylang_internals/compiler/cfg_compiler.py

@@ -24,7 +24,7 @@ from guppylang_internals.compiler.core import (
 from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.compiler.stmt_compiler import StmtCompiler
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, read_bool
-from guppylang_internals.tys.ty import SumType, row_to_type, type_to_row
+from guppylang_internals.tys.ty import type_to_row
 
 
 def compile_cfg(
@@ -38,7 +38,7 @@ def compile_cfg(
     # TODO: This mutates the CFG in-place which leads to problems when trying to lower
     #  the same function to Hugr twice. For now we just check that the return vars
     #  haven't already been inserted, but we should figure out a better way to handle
-    #  this: https://github.com/CQCL/guppylang/issues/428
+    #  this: https://github.com/quantinuum/guppylang/issues/428
     if all(
         not is_return_var(v.name)
         for v in cfg.exit_bb.sig.input_row
@@ -52,7 +52,7 @@ def compile_cfg(
     # unreachable
     out_tys = [place.ty.to_hugr(ctx) for place in cfg.exit_bb.sig.input_row]
     # TODO: Use proper API for this once it's added in hugr-py:
-    #  https://github.com/CQCL/hugr/issues/1816
+    #  https://github.com/quantinuum/hugr/issues/1816
     builder._exit_op._cfg_outputs = out_tys
     builder.parent_op._outputs = out_tys
     builder.parent_node = builder.hugr._update_node_outs(
@@ -194,13 +194,14 @@ def choose_vars_for_tuple_sum(
     constructs a TupleSum value of type `Sum(#s1, #s2, ...)`.
     """
     assert all(v.ty.droppable for var_row in output_vars for v in var_row)
-    tys = [[v.ty for v in var_row] for var_row in output_vars]
-    sum_type = SumType([row_to_type(row) for row in tys]).to_hugr(dfg.ctx)
+    sum_type = ht.Sum(
+        [[v.ty.to_hugr(dfg.ctx) for v in var_row] for var_row in output_vars]
+    )
 
     # We pass all values into the conditional instead of relying on non-local edges.
     # This is because we can't handle them in lower parts of the stack yet :/
     # TODO: Reinstate use of non-local edges.
-    #  See https://github.com/CQCL/guppylang/issues/963
+    #  See https://github.com/quantinuum/guppylang/issues/963
     all_vars = {v.id: dfg[v] for var_row in output_vars for v in var_row}
     all_vars_wires = list(all_vars.values())
     all_vars_idxs = {x: i for i, x in enumerate(all_vars.keys())}